This is an archive of the discontinued LLVM Phabricator instance.

Differential D78738

[OPENMP50]Support 'task' modifier in reduction clauses.
ClosedPublic

Authored by ABataev on Apr 23 2020, 11:32 AM.

Details

Reviewers
jdoerfert
Commits
rG1c1d9d9d7fd3: [OPENMP50]Support 'task' modifier in reduction clauses.
Summary

Added basic support for 'task' modifier in the reduction clauses in
non-simd parallel and worksharing constructs.

Diff Detail

Unit TestsFailed

TimeTest
130 mslldb-unit.Host/_/HostTests::Unknown Unit Message ("")

Event Timeline

ABataev created this revision.Apr 23 2020, 11:32 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 23 2020, 11:32 AM
Herald added subscribers: guansong, yaxunl. · View Herald Transcript
Harbormaster failed remote builds in B54451: Diff 259650!Apr 23 2020, 2:08 PM
ABataev added a child revision: D79034: [OPENMP50]Codegen for reduction clauses with 'task' modifier..Apr 28 2020, 12:48 PM
jdoerfert accepted this revision.Apr 30 2020, 5:41 AM

I'm assuming we do not have to check that no one uses task, inscan: + : m, right? If so, LGTM.

This revision is now accepted and ready to land.Apr 30 2020, 5:41 AM
Closed by commit rG1c1d9d9d7fd3: [OPENMP50]Support 'task' modifier in reduction clauses. (authored by ABataev). · Explain WhyApr 30 2020, 11:48 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
include/
clang/
Basic/
3 lines
1 line
lib/
Sema/
18 lines
test/
OpenMP/
4 lines
23 lines
23 lines
23 lines
4 lines
21 lines
21 lines
21 lines
21 lines
8 lines
4 lines
3 lines
21 lines
8 lines
22 lines
4 lines
21 lines
21 lines
2 lines
20 lines
16 lines
22 lines
16 lines
22 lines
21 lines
16 lines
4 lines
21 lines
21 lines
20 lines
20 lines
21 lines
4 lines
20 lines
20 lines
20 lines
20 lines
20 lines
21 lines
21 lines
4 lines
21 lines
21 lines
21 lines
21 lines
21 lines

Diff 259650

clang/include/clang/Basic/DiagnosticSemaKinds.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 10,220 Lines • ▼ Show 20 Linesdef err_omp_event_var_expected : Error<
"expected variable of the 'omp_event_handle_t' type%select{|, not %1}0">; "expected variable of the 'omp_event_handle_t' type%select{|, not %1}0">;
def warn_nested_declare_variant def warn_nested_declare_variant
: Warning<"nesting `omp begin/end declare variant` is not supported yet; " : Warning<"nesting `omp begin/end declare variant` is not supported yet; "
"nested context ignored">, "nested context ignored">,
InGroup<SourceUsesOpenMP>; InGroup<SourceUsesOpenMP>;
def err_omp_non_pointer_type_array_shaping_base : Error< def err_omp_non_pointer_type_array_shaping_base : Error<
"expected expression with a pointer to a complete type as a base of an array " "expected expression with a pointer to a complete type as a base of an array "
"shaping operation">; "shaping operation">;
def err_omp_reduction_task_not_parallel_or_worksharing : Error<
"'reduction' clause with 'task' modifier allowed only on non-simd parallel or"
" worksharing constructs">;
} // end of OpenMP category } // end of OpenMP category
let CategoryName = "Related Result Type Issue" in { let CategoryName = "Related Result Type Issue" in {
// Objective-C related result type compatibility // Objective-C related result type compatibility
def warn_related_result_type_compatibility_class : Warning< def warn_related_result_type_compatibility_class : Warning<
"method is expected to return an instance of its class type " "method is expected to return an instance of its class type "
"%diff{$, but is declared to return $|" "%diff{$, but is declared to return $|"
", but is declared to return different type}0,1">; ", but is declared to return different type}0,1">;
▲ Show 20 Lines • Show All 488 Lines • Show Last 20 Lines

clang/include/clang/Basic/OpenMPKinds.def

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
OPENMP_LASTPRIVATE_KIND(conditional) OPENMP_LASTPRIVATE_KIND(conditional)
// Type of the 'order' clause. // Type of the 'order' clause.
OPENMP_ORDER_KIND(concurrent) OPENMP_ORDER_KIND(concurrent)
// Modifiers for 'reduction' clause. // Modifiers for 'reduction' clause.
OPENMP_REDUCTION_MODIFIER(default) OPENMP_REDUCTION_MODIFIER(default)
OPENMP_REDUCTION_MODIFIER(inscan) OPENMP_REDUCTION_MODIFIER(inscan)
OPENMP_REDUCTION_MODIFIER(task)
#undef OPENMP_REDUCTION_MODIFIER #undef OPENMP_REDUCTION_MODIFIER
#undef OPENMP_DEVICE_MODIFIER #undef OPENMP_DEVICE_MODIFIER
#undef OPENMP_ORDER_KIND #undef OPENMP_ORDER_KIND
#undef OPENMP_LASTPRIVATE_KIND #undef OPENMP_LASTPRIVATE_KIND
#undef OPENMP_DEVICE_TYPE_KIND #undef OPENMP_DEVICE_TYPE_KIND
#undef OPENMP_LINEAR_KIND #undef OPENMP_LINEAR_KIND
#undef OPENMP_DEPEND_KIND #undef OPENMP_DEPEND_KIND
Show All 11 Lines

clang/lib/Sema/SemaOpenMP.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,360 Lines • ▼ Show 20 Lines
} }
static std::pair<ValueDecl *, bool> static std::pair<ValueDecl *, bool>
getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc, getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
SourceRange &ERange, bool AllowArraySection = false); SourceRange &ERange, bool AllowArraySection = false);
/// Check consistency of the reduction clauses. /// Check consistency of the reduction clauses.
static void checkReductionClauses(Sema &S, DSAStackTy *Stack, static void checkReductionClauses(Sema &S, DSAStackTy *Stack,
ArrayRef<OMPClause *> Clauses) { ArrayRef<OMPClause *> Clauses) {
bool InscanFound = false; bool InscanFound = false;
SourceLocation InscanLoc; SourceLocation InscanLoc;
// OpenMP 5.0, 2.19.5.4 reduction Clause, Restrictions. // OpenMP 5.0, 2.19.5.4 reduction Clause, Restrictions.
// A reduction clause without the inscan reduction-modifier may not appear on // A reduction clause without the inscan reduction-modifier may not appear on
// a construct on which a reduction clause with the inscan reduction-modifier // a construct on which a reduction clause with the inscan reduction-modifier
// appears. // appears.
for (OMPClause *C : Clauses) { for (OMPClause *C : Clauses) {
if (C->getClauseKind() != OMPC_reduction) if (C->getClauseKind() != OMPC_reduction)
continue; continue;
auto *RC = cast<OMPReductionClause>(C); auto *RC = cast<OMPReductionClause>(C);
if (RC->getModifier() == OMPC_REDUCTION_inscan) { if (RC->getModifier() == OMPC_REDUCTION_inscan) {
InscanFound = true; InscanFound = true;
InscanLoc = RC->getModifierLoc(); InscanLoc = RC->getModifierLoc();
break; continue;
}
if (RC->getModifier() == OMPC_REDUCTION_task) {
// OpenMP 5.0, 2.19.5.4 reduction Clause.
// A reduction clause with the task reduction-modifier may only appear on
// a parallel construct, a worksharing construct or a combined or
// composite construct for which any of the aforementioned constructs is a
// constituent construct and simd or loop are not constituent constructs.
OpenMPDirectiveKind CurDir = Stack->getCurrentDirective();
if (!(isOpenMPParallelDirective(CurDir) ||
isOpenMPWorksharingDirective(CurDir)) ||
isOpenMPSimdDirective(CurDir))
S.Diag(RC->getModifierLoc(),
diag::err_omp_reduction_task_not_parallel_or_worksharing);
continue;
} }
} }
if (InscanFound) { if (InscanFound) {
for (OMPClause *C : Clauses) { for (OMPClause *C : Clauses) {
if (C->getClauseKind() != OMPC_reduction) if (C->getClauseKind() != OMPC_reduction)
continue; continue;
auto *RC = cast<OMPReductionClause>(C); auto *RC = cast<OMPReductionClause>(C);
if (RC->getModifier() != OMPC_REDUCTION_inscan) { if (RC->getModifier() != OMPC_REDUCTION_inscan) {
▲ Show 20 Lines • Show All 16,047 Lines • Show Last 20 Lines

clang/test/OpenMP/distribute_parallel_for_ast_print.cpp

// RUN: %clang_cc1 -verify -std=c++11 -fopenmp -fopenmp-version=45 -ast-print %s -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK --check-prefix=OMP45 // RUN: %clang_cc1 -verify -std=c++11 -fopenmp -fopenmp-version=45 -ast-print %s -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK --check-prefix=OMP45
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK --check-prefix=OMP45 // RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK --check-prefix=OMP45
// RUN: %clang_cc1 -verify -std=c++11 -fopenmp -fopenmp-version=50 -ast-print %s -Wno-openmp-mapping -DOMP5 | FileCheck %s --check-prefix=CHECK --check-prefix=OMP50 // RUN: %clang_cc1 -verify -std=c++11 -fopenmp -fopenmp-version=50 -ast-print %s -Wno-openmp-mapping -DOMP5 | FileCheck %s --check-prefix=CHECK --check-prefix=OMP50
// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s -DOMP5 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s -DOMP5
// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print -Wno-openmp-mapping -DOMP5 | FileCheck %s --check-prefix=CHECK --check-prefix=OMP50 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print -Wno-openmp-mapping -DOMP5 | FileCheck %s --check-prefix=CHECK --check-prefix=OMP50
// RUN: %clang_cc1 -verify -std=c++11 -fopenmp-simd -fopenmp-version=45 -ast-print %s -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK --check-prefix=OMP45 // RUN: %clang_cc1 -verify -std=c++11 -fopenmp-simd -fopenmp-version=45 -ast-print %s -Wno-openmp-mapping | FileCheck %s --check-prefix=CHECK --check-prefix=OMP45
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Linesint main(int argc, char **argv) {
int b = argc, c, d, e, f, h; int b = argc, c, d, e, f, h;
static int a; static int a;
// CHECK: static int a; // CHECK: static int a;
static float g; static float g;
#pragma omp threadprivate(g) #pragma omp threadprivate(g)
#pragma omp target #pragma omp target
#pragma omp teams #pragma omp teams
#ifdef OMP5 #ifdef OMP5
#pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) order(concurrent) #pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) order(concurrent) reduction(task,+:c)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) order(concurrent) reduction(task,+:c)
+#pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) order(concurrent) reduction(task, + \
+                                                                                                                                                                : c)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp distribute parallel for schedule(guided…
#else #else
#pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) #pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc)
#endif // OMP5 #endif // OMP5
// OMP45: #pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) // OMP45: #pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc)
// OMP50: #pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) order(concurrent) // OMP50: #pragma omp distribute parallel for schedule(guided, argc) default(none) copyin(g) dist_schedule(static, a) private(a) shared(argc) order(concurrent) reduction(task, +: c)
for (int i = 0; i < 2; ++i) for (int i = 0; i < 2; ++i)
a = 2; a = 2;
// CHECK-NEXT: for (int i = 0; i < 2; ++i) // CHECK-NEXT: for (int i = 0; i < 2; ++i)
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
#pragma omp target #pragma omp target
#pragma omp teams #pragma omp teams
#pragma omp distribute parallel for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) schedule(auto) if (argc) num_threads(a) default(shared) shared(e) reduction(+ : h) dist_schedule(static, b) #pragma omp distribute parallel for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) schedule(auto) if (argc) num_threads(a) default(shared) shared(e) reduction(+ : h) dist_schedule(static, b)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
Show All 10 Lines

clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp distribute parallel for reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp distribute parallel for reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 436 Lines • ▼ Show 20 Lines#pragma omp distribute parallel for reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams #pragma omp teams
#pragma omp distribute parallel for reduction(+ : m) // OK #pragma omp distribute parallel for reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp distribute parallel for reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp distribute parallel for reduction(task, + \
+                                              : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp distribute parallel for reduction(task…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/distribute_parallel_for_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wno-openmp-mapping -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp distribute parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp distribute parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
} }
▲ Show 20 Lines • Show All 435 Lines • ▼ Show 20 Lines#pragma omp distribute parallel for simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams #pragma omp teams
#pragma omp distribute parallel for simd reduction(+ : m) // OK #pragma omp distribute parallel for simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp target
#pragma omp teams
#pragma omp distribute parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp distribute parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp distribute parallel for simd reduction(task, + \
+                                                   : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp distribute parallel for simd reduction…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/distribute_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp distribute simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp distribute simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
} }
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Lines#pragma omp distribute simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp target #pragma omp target
#pragma omp teams #pragma omp teams
#pragma omp distribute simd reduction(+ : fl) #pragma omp distribute simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
#pragma omp target
#pragma omp teams
#pragma omp distribute simd reduction(task, + : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error 3 {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp distribute simd reduction(task, + : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error 3 {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp distribute simd reduction(task, + \
+                                      : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error 3 {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp distribute simd reduction(task, + : fl)…
for (int i = 0; i < 10; ++i)
foo();
return T(); return T();
} }
namespace A { namespace A {
double x; double x;
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}} #pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
} }
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

clang/test/OpenMP/for_ast_print.cpp

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
// CHECK: static int a; // CHECK: static int a;
#pragma omp for schedule(guided, argc) reduction(+:argv[0][:1]) order(concurrent) #pragma omp for schedule(guided, argc) reduction(+:argv[0][:1]) order(concurrent)
// CHECK-NEXT: #pragma omp for schedule(guided, argc) reduction(+: argv[0][:1]) order(concurrent) // CHECK-NEXT: #pragma omp for schedule(guided, argc) reduction(+: argv[0][:1]) order(concurrent)
for (int i = 0; i < 2; ++i) for (int i = 0; i < 2; ++i)
a = 2; a = 2;
// CHECK-NEXT: for (int i = 0; i < 2; ++i) // CHECK-NEXT: for (int i = 0; i < 2; ++i)
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
#pragma omp parallel #pragma omp parallel
#pragma omp for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(3) schedule(auto) ordered nowait linear(g:-1) #pragma omp for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(3) schedule(auto) ordered nowait linear(g:-1) reduction(task, +:e)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(3) schedule(auto) ordered nowait linear(g:-1) reduction(task, +:e)
+#pragma omp for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(3) schedule(auto) ordered nowait linear(g                       \
+                                                                                                                            : -1) reduction(task, + \
+                                                                                                                                            : e)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp for private(argc, b), firstprivate(argv…
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j) for (int j = 0; j < 10; ++j)
for (auto x : arr) for (auto x : arr)
foo(), (void)x; foo(), (void)x;
// CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: #pragma omp parallel
// CHECK-NEXT: #pragma omp for private(argc,b) firstprivate(argv,c) lastprivate(d,f) collapse(3) schedule(auto) ordered nowait linear(g: -1) // CHECK-NEXT: #pragma omp for private(argc,b) firstprivate(argv,c) lastprivate(d,f) collapse(3) schedule(auto) ordered nowait linear(g: -1) reduction(task, +: e)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // 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 (auto x : arr) // CHECK-NEXT: for (auto x : arr)
// CHECK-NEXT: foo() , (void)x; // CHECK-NEXT: foo() , (void)x;
char buf[9] = "01234567"; char buf[9] = "01234567";
char *p, *q; char *p, *q;
#pragma omp parallel #pragma omp parallel
#pragma omp for #pragma omp for
Show All 12 Lines

clang/test/OpenMP/for_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel #pragma omp parallel
#pragma omp for reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp for reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 383 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}} #pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}}
#pragma omp for reduction(+ : fl) // expected-error {{reduction variable must be shared}} #pragma omp for reduction(+ : fl) // expected-error {{reduction variable must be shared}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m=0; static int m=0;
#pragma omp for reduction(+:m) #pragma omp for reduction(+:m)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp for reduction(task, +:m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp for reduction(task, +:m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp for reduction(task, + \
+                          : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp for reduction(task, +:m) // omp45-error…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/for_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel #pragma omp parallel
#pragma omp for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 362 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}} #pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}}
#pragma omp for simd reduction(+ : fl) // expected-error {{reduction variable must be shared}} #pragma omp for simd reduction(+ : fl) // expected-error {{reduction variable must be shared}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp for simd reduction(+ : m) #pragma omp for simd reduction(+ : m)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp for simd reduction(task, + \
+                               : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp for simd reduction(task, + : m) //…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/master_taskloop_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 326 Lines • ▼ Show 20 Lines for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp master taskloop reduction(+ : m) // OK #pragma omp master taskloop reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp master taskloop nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}} #pragma omp master taskloop nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp master taskloop reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp master taskloop reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp master taskloop reduction(task, + \
+                                      : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp master taskloop reduction(task, + : m)…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/master_taskloop_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 326 Lines • ▼ Show 20 Lines for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp master taskloop simd reduction(+ : m) // OK #pragma omp master taskloop simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp master taskloop simd reduction(+ : m) nogroup // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}} #pragma omp master taskloop simd reduction(+ : m) nogroup // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp master taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp master taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp master taskloop simd reduction(task, + \
+                                           : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp master taskloop simd reduction(task, +…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/parallel_ast_print.cpp

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 LinesT tmain(T argc, T *argv) {
T b = argc, c, d, e, f, g; T b = argc, c, d, e, f, g;
static T a; static T a;
S<T> s; S<T> s;
T arr[C][10], arr1[C]; T arr[C][10], arr1[C];
#pragma omp parallel #pragma omp parallel
a=2; a=2;
#pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared (d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS, thrp) proc_bind(master) reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10]) #pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared (d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS, thrp) proc_bind(master) reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10])
foo(); foo();
#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(default, && : g) #pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(default, && : g) reduction(task,+:argc)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(default, && : g) reduction(task,+:argc)
+#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^                                                          \
+                                                                      : e, f, arr [0:C][:argc]) reduction(default, &&            \
+                                                                                                          : g) reduction(task, + \
+                                                                                                                         : argc)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel if (C) num_threads(s)…
foo(); foo();
return 0; return 0;
} }
// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
// CHECK-NEXT: T b = argc, c, d, e, f, g; // CHECK-NEXT: T b = argc, c, d, e, f, g;
// CHECK-NEXT: static T a; // CHECK-NEXT: static T a;
// CHECK-NEXT: S<T> s; // CHECK-NEXT: S<T> s;
// CHECK-NEXT: T arr[C][10], arr1[C]; // CHECK-NEXT: T arr[C][10], arr1[C];
// CHECK-NEXT: #pragma omp parallel{{$}} // CHECK-NEXT: #pragma omp parallel{{$}}
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10]) // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10])
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(default, &&: g) // CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(default, &&: g) reduction(task, +: argc)
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK: template<> int tmain<int, 5>(int argc, int *argv) { // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {
// CHECK-NEXT: int b = argc, c, d, e, f, g; // CHECK-NEXT: int b = argc, c, d, e, f, g;
// CHECK-NEXT: static int a; // CHECK-NEXT: static int a;
// CHECK-NEXT: S<int> s; // CHECK-NEXT: S<int> s;
// CHECK-NEXT: int arr[5][10], arr1[5]; // CHECK-NEXT: int arr[5][10], arr1[5];
// CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: #pragma omp parallel
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) copyin(S<int>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:5][0:10]) // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) copyin(S<int>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:5][0:10])
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK-NEXT: #pragma omp parallel if(5) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:5][:argc]) reduction(default, &&: g) // CHECK-NEXT: #pragma omp parallel if(5) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:5][:argc]) reduction(default, &&: g) reduction(task, +: argc)
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK: template<> long tmain<long, 1>(long argc, long *argv) { // CHECK: template<> long tmain<long, 1>(long argc, long *argv) {
// CHECK-NEXT: long b = argc, c, d, e, f, g; // CHECK-NEXT: long b = argc, c, d, e, f, g;
// CHECK-NEXT: static long a; // CHECK-NEXT: static long a;
// CHECK-NEXT: S<long> s; // CHECK-NEXT: S<long> s;
// CHECK-NEXT: long arr[1][10], arr1[1]; // CHECK-NEXT: long arr[1][10], arr1[1];
// CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: #pragma omp parallel
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) copyin(S<long>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:1][0:10]) // CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) copyin(S<long>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:1][0:10])
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK-NEXT: #pragma omp parallel if(1) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:1][:argc]) reduction(default, &&: g) // CHECK-NEXT: #pragma omp parallel if(1) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:1][:argc]) reduction(default, &&: g) reduction(task, +: argc)
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
enum Enum { }; enum Enum { };
int main (int argc, char **argv) { int main (int argc, char **argv) {
long x; long x;
int b = argc, c, d, e, f, g; int b = argc, c, d, e, f, g;
static int a; static int a;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_for_ast_print.cpp

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
int main(int argc, char **argv) { int main(int argc, char **argv) {
int b = argc, c, d, e, f, h; int b = argc, c, d, e, f, h;
static int a; static int a;
// CHECK: static int a; // CHECK: static int a;
static float g; static float g;
#pragma omp threadprivate(g) #pragma omp threadprivate(g)
#pragma omp parallel for schedule(guided, argc) default(none) copyin(g) linear(a) shared(argc) #pragma omp parallel for schedule(guided, argc) default(none) copyin(g) linear(a) shared(argc) reduction(task,&:d)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel for schedule(guided, argc) default(none) copyin(g) linear(a) shared(argc) reduction(task,&:d)
+#pragma omp parallel for schedule(guided, argc) default(none) copyin(g) linear(a) shared(argc) reduction(task, & \
+                                                                                                         : d)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel for schedule(guided, argc)…
// CHECK: #pragma omp parallel for schedule(guided, argc) default(none) copyin(g) linear(a) shared(argc) // CHECK: #pragma omp parallel for schedule(guided, argc) default(none) copyin(g) linear(a) shared(argc) reduction(task, &: d)
for (int i = 0; i < 2; ++i) for (int i = 0; i < 2; ++i)
a = 2; a = 2;
// CHECK-NEXT: for (int i = 0; i < 2; ++i) // CHECK-NEXT: for (int i = 0; i < 2; ++i)
// CHECK-NEXT: a = 2; // 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) linear(a:-5) #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) linear(a:-5)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j) for (int j = 0; j < 10; ++j)
foo(); 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) linear(a: -5) // 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) linear(a: -5)
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // 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: foo(); // CHECK-NEXT: foo();
return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0])); return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0]));
} }
#endif #endif

clang/test/OpenMP/parallel_for_reduction_messages.cpp

Show First 20 Lines • Show All 334 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp parallel for reduction(+ : fl) #pragma omp parallel for reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp parallel for reduction(+ : m) // OK #pragma omp parallel for reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp parallel for reduction(task, + : m) // OK
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel for reduction(task, + : m) // OK
+#pragma omp parallel for reduction(task, + \
+                                   : m) // OK
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel for reduction(task, + : m) //…
for (int i = 0; i < 10; ++i)
m++;
#pragma omp parallel for reduction(inscan, + : m) reduction(*: fl) reduction(default, &&: j) // expected-error 2 {{expected 'reduction' clause with the 'inscan' modifier}} expected-note 2 {{'reduction' clause with 'inscan' modifier is used here}} #pragma omp parallel for reduction(inscan, + : m) reduction(*: fl) reduction(default, &&: j) // expected-error 2 {{expected 'reduction' clause with the 'inscan' modifier}} expected-note 2 {{'reduction' clause with 'inscan' modifier is used here}}
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
#pragma omp scan exclusive(m) #pragma omp scan exclusive(m)
m++; m++;
} }
#pragma omp parallel for reduction(inscan, + : m, fl, j) // expected-error 2 {{the inscan reduction list item must appear as a list item in an 'inclusive' or 'exclusive' clause on an inner 'omp scan' directive}} #pragma omp parallel for reduction(inscan, + : m, fl, j) // expected-error 2 {{the inscan reduction list item must appear as a list item in an 'inclusive' or 'exclusive' clause on an inner 'omp scan' directive}}
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
Show All 11 Lines

clang/test/OpenMP/parallel_for_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
} }
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp parallel for simd reduction(+ : fl) #pragma omp parallel for simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp parallel for simd reduction(+ : m) // OK #pragma omp parallel for simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp parallel for simd reduction(task, + \
+                                        : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel for simd reduction(task, +…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/parallel_master_ast_print.cpp

Show First 20 Lines • Show All 146 Lines • ▼ Show 20 LinesT tmain(T argc, T *argv) {
T b = argc, c, d, e, f, g; T b = argc, c, d, e, f, g;
static T a; static T a;
S<T> s; S<T> s;
T arr[C][10], arr1[C]; T arr[C][10], arr1[C];
#pragma omp parallel master #pragma omp parallel master
a=2; a=2;
#pragma omp parallel master default(none), private(argc,b) firstprivate(argv) shared (d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS, thrp) proc_bind(master) reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10]) #pragma omp parallel master default(none), private(argc,b) firstprivate(argv) shared (d) if (parallel:argc > 0) num_threads(C) copyin(S<T>::TS, thrp) proc_bind(master) reduction(+:c, arr1[argc]) reduction(max:e, arr[:C][0:10])
foo(); foo();
#pragma omp parallel master if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(&& : g) #pragma omp parallel master if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(task, && : g)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel master if (C) num_threads(s) proc_bind(close) reduction(^:e, f, arr[0:C][:argc]) reduction(task, && : g)
+#pragma omp parallel master if (C) num_threads(s) proc_bind(close) reduction(^                                            \
+                                                                             : e, f, arr [0:C][:argc]) reduction(task, && \
+                                                                                                                 : g)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel master if (C) num_threads(s)…
foo(); foo();
return 0; return 0;
} }
// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
// CHECK-NEXT: T b = argc, c, d, e, f, g; // CHECK-NEXT: T b = argc, c, d, e, f, g;
// CHECK-NEXT: static T a; // CHECK-NEXT: static T a;
// CHECK-NEXT: S<T> s; // CHECK-NEXT: S<T> s;
// CHECK-NEXT: T arr[C][10], arr1[C]; // CHECK-NEXT: T arr[C][10], arr1[C];
// CHECK-NEXT: #pragma omp parallel master{{$}} // CHECK-NEXT: #pragma omp parallel master{{$}}
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: #pragma omp parallel master default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10]) // CHECK-NEXT: #pragma omp parallel master default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(C) copyin(S<T>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:C][0:10])
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK-NEXT: #pragma omp parallel master if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(&&: g) // CHECK-NEXT: #pragma omp parallel master if(C) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:C][:argc]) reduction(task, &&: g)
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK: template<> int tmain<int, 5>(int argc, int *argv) { // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {
// CHECK-NEXT: int b = argc, c, d, e, f, g; // CHECK-NEXT: int b = argc, c, d, e, f, g;
// CHECK-NEXT: static int a; // CHECK-NEXT: static int a;
// CHECK-NEXT: S<int> s; // CHECK-NEXT: S<int> s;
// CHECK-NEXT: int arr[5][10], arr1[5]; // CHECK-NEXT: int arr[5][10], arr1[5];
// CHECK-NEXT: #pragma omp parallel master // CHECK-NEXT: #pragma omp parallel master
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: #pragma omp parallel master default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) copyin(S<int>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:5][0:10]) // CHECK-NEXT: #pragma omp parallel master default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(5) copyin(S<int>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:5][0:10])
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK-NEXT: #pragma omp parallel master if(5) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:5][:argc]) reduction(&&: g) // CHECK-NEXT: #pragma omp parallel master if(5) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:5][:argc]) reduction(task, &&: g)
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK: template<> long tmain<long, 1>(long argc, long *argv) { // CHECK: template<> long tmain<long, 1>(long argc, long *argv) {
// CHECK-NEXT: long b = argc, c, d, e, f, g; // CHECK-NEXT: long b = argc, c, d, e, f, g;
// CHECK-NEXT: static long a; // CHECK-NEXT: static long a;
// CHECK-NEXT: S<long> s; // CHECK-NEXT: S<long> s;
// CHECK-NEXT: long arr[1][10], arr1[1]; // CHECK-NEXT: long arr[1][10], arr1[1];
// CHECK-NEXT: #pragma omp parallel master // CHECK-NEXT: #pragma omp parallel master
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: #pragma omp parallel master default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) copyin(S<long>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:1][0:10]) // CHECK-NEXT: #pragma omp parallel master default(none) private(argc,b) firstprivate(argv) shared(d) if(parallel: argc > 0) num_threads(1) copyin(S<long>::TS,thrp) proc_bind(master) reduction(+: c,arr1[argc]) reduction(max: e,arr[:1][0:10])
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
// CHECK-NEXT: #pragma omp parallel master if(1) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:1][:argc]) reduction(&&: g) // CHECK-NEXT: #pragma omp parallel master if(1) num_threads(s) proc_bind(close) reduction(^: e,f,arr[0:1][:argc]) reduction(task, &&: g)
// CHECK-NEXT: foo() // CHECK-NEXT: foo()
enum Enum { }; enum Enum { };
int main (int argc, char **argv) { int main (int argc, char **argv) {
long x; long x;
int b = argc, c, d, e, f, g; int b = argc, c, d, e, f, g;
static int a; static int a;
Show All 23 Lines

clang/test/OpenMP/parallel_master_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel master reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp parallel master reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
{ {
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 372 Lines • ▼ Show 20 Lines#pragma omp parallel master reduction(+ : fl)
{ {
foo(); foo();
} }
static int m; static int m;
#pragma omp parallel master reduction(+ : m) // OK #pragma omp parallel master reduction(+ : m) // OK
{ {
foo(); foo();
} }
#pragma omp parallel master reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel master reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp parallel master reduction(task, + \
+                                      : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel master reduction(task, + : m)…
{
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}} 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}}
} }

clang/test/OpenMP/parallel_master_taskloop_ast_print.cpp

Show All 12 Lines
void foo() {} void foo() {}
template <class T, int N> template <class T, int N>
T tmain(T argc) { T tmain(T argc) {
T b = argc, c, d, e, f, g; T b = argc, c, d, e, f, g;
static T a; static T a;
// CHECK: static T a; // CHECK: static T a;
#pragma omp taskgroup allocate(d) task_reduction(+: d) #pragma omp taskgroup allocate(d) task_reduction(+: d)
#pragma omp parallel master taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+:g) allocate(g) #pragma omp parallel master taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+:g) allocate(g) reduction(task,^:c)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel master taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+:g) allocate(g) reduction(task,^:c)
+#pragma omp parallel master taskloop if (taskloop                                                                                                 \
+                                         : argc > N) default(shared) untied priority(N) grainsize(N) reduction(+                                  \
+                                                                                                               : g) allocate(g) reduction(task, ^ \
+                                                                                                                                          : c)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel master taskloop if(taskloop…
// CHECK-NEXT: #pragma omp taskgroup allocate(d) task_reduction(+: d) // CHECK-NEXT: #pragma omp taskgroup allocate(d) task_reduction(+: d)
// CHECK-NEXT: #pragma omp parallel master taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+: g) allocate(g){{$}} // CHECK-NEXT: #pragma omp parallel master taskloop if(taskloop: argc > N) default(shared) untied priority(N) grainsize(N) reduction(+: g) allocate(g) reduction(task, ^: c){{$}}
for (int i = 0; i < 2; ++i) for (int i = 0; i < 2; ++i)
a = 2; a = 2;
// CHECK-NEXT: for (int i = 0; i < 2; ++i) // CHECK-NEXT: for (int i = 0; i < 2; ++i)
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
#pragma omp parallel #pragma omp parallel
#pragma omp parallel master taskloop private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) shared(g) if (c) final(d) mergeable priority(f) nogroup num_tasks(N) #pragma omp parallel master taskloop private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) shared(g) if (c) final(d) mergeable priority(f) nogroup num_tasks(N)
for (int i = 0; i < 2; ++i) for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) for (int j = 0; j < 2; ++j)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

clang/test/OpenMP/parallel_master_taskloop_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp parallel master taskloop reduction(+ : fl) #pragma omp parallel master taskloop reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp parallel master taskloop reduction(+ : m) // OK #pragma omp parallel master taskloop reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp parallel master taskloop reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel master taskloop reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp parallel master taskloop reduction(task, + \
+                                               : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel master taskloop reduction(task…
for (int i = 0; i < 10; ++i)
m++;
#pragma omp parallel master taskloop nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}} #pragma omp parallel master taskloop nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
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}} 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}}
} }

clang/test/OpenMP/parallel_master_taskloop_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp parallel master taskloop simd reduction(+ : fl) #pragma omp parallel master taskloop simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp parallel master taskloop simd reduction(+ : m) // OK #pragma omp parallel master taskloop simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp parallel master taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel master taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp parallel master taskloop simd reduction(task, + \
+                                                    : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel master taskloop simd reduction…
for (int i = 0; i < 10; ++i)
m++;
#pragma omp parallel master taskloop simd nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}} #pragma omp parallel master taskloop simd nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
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}} 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}}
} }

clang/test/OpenMP/parallel_reduction_messages.c

// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s
int incomplete[]; int incomplete[];
void test(int *p) { void test(int *p) {
int a; int a;
#pragma omp parallel reduction( // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-note {{to match this '('}} #pragma omp parallel reduction( // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-note {{to match this '('}}
; ;
#pragma omp parallel reduction(unknown // expected-error {{expected expression}} expected-error {{expected ')'}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-note {{to match this '('}} #pragma omp parallel reduction(unknown // expected-error {{expected expression}} expected-error {{expected ')'}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-note {{to match this '('}}
; ;
#pragma omp parallel reduction(default, // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-note {{to match this '('}} #pragma omp parallel reduction(default, // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-note {{to match this '('}}
; ;
#pragma omp parallel reduction(unknown, +: a) // expected-error {{expected 'default' or 'inscan' in OpenMP clause 'reduction'}} #pragma omp parallel reduction(unknown, +: a) // expected-error {{expected 'default', 'inscan' or 'task' in OpenMP clause 'reduction'}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel reduction(unknown, +: a) // expected-error {{expected 'default', 'inscan' or 'task' in OpenMP clause 'reduction'}}
+#pragma omp parallel reduction(unknown, + \
+                               : a) // expected-error {{expected 'default', 'inscan' or 'task' in OpenMP clause 'reduction'}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel reduction(unknown, +: a) //…
; ;
#pragma omp parallel reduction(default, + : a) #pragma omp parallel reduction(default, + : a)
; ;
#pragma omp parallel reduction(inscan, + : a) // expected-error {{'inscan' modifier can be used only in 'omp for', 'omp simd', 'omp for simd', 'omp parallel for', or 'omp parallel for simd' directive}} #pragma omp parallel reduction(inscan, + : a) // expected-error {{'inscan' modifier can be used only in 'omp for', 'omp simd', 'omp for simd', 'omp parallel for', or 'omp parallel for simd' directive}}
; ;
#pragma omp parallel reduction(+ : incomplete, ([10])p) // expected-error {{a reduction list item with incomplete type 'int []'}} expected-error {{expected variable name, array element or array section}} #pragma omp parallel reduction(+ : incomplete, ([10])p) // expected-error {{a reduction list item with incomplete type 'int []'}} expected-error {{expected variable name, array element or array section}}
; ;
} }
// complete to suppress an additional warning, but it's too late for pragmas // complete to suppress an additional warning, but it's too late for pragmas
int incomplete[3]; int incomplete[3];

clang/test/OpenMP/parallel_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp parallel reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
} }
▲ Show 20 Lines • Show All 248 Lines • ▼ Show 20 Lines
#pragma omp parallel #pragma omp parallel
#pragma omp for reduction(- : fl) #pragma omp for reduction(- : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
#pragma omp parallel reduction(+ : fl) #pragma omp parallel reduction(+ : fl)
foo(); foo();
static int m; static int m;
#pragma omp parallel reduction(+ : m) // OK #pragma omp parallel reduction(+ : m) // OK
m++; m++;
#pragma omp parallel reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp parallel reduction(task, + \
+                               : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel reduction(task, + : m) //…
m++;
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}} 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}}
} }

clang/test/OpenMP/parallel_sections_ast_print.cpp

// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=50 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
void foo() {} void foo() {}
template <class T> template <class T>
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
int main(int argc, char **argv) { int main(int argc, char **argv) {
long x; long x;
int b = argc, c, d, e, f, g; int b = argc, c, d, e, f, g;
static int a; static int a;
#pragma omp threadprivate(a) #pragma omp threadprivate(a)
Enum ee; Enum ee;
// CHECK: Enum ee; // CHECK: Enum ee;
#pragma omp parallel sections #pragma omp parallel sections reduction(task,*:f)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel sections reduction(task,*:f)
+#pragma omp parallel sections reduction(task, * \
+                                        : f)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel sections reduction(task,*:f)…
// CHECK-NEXT: #pragma omp parallel sections // CHECK-NEXT: #pragma omp parallel sections reduction(task, *: f)
{ {
a = 2; a = 2;
} }
// CHECK-NEXT: { // CHECK-NEXT: {
// CHECK-NEXT: a = 2; // CHECK-NEXT: a = 2;
// CHECK-NEXT: } // 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) #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) // 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)
Show All 21 Lines

clang/test/OpenMP/parallel_sections_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel sections reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp parallel sections reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
{ {
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 372 Lines • ▼ Show 20 Lines#pragma omp parallel sections reduction(+ : fl)
{ {
foo(); foo();
} }
static int m; static int m;
#pragma omp parallel sections reduction(+ : m) // OK #pragma omp parallel sections reduction(+ : m) // OK
{ {
foo(); foo();
} }
#pragma omp parallel sections reduction(task,+ : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp parallel sections reduction(task,+ : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp parallel sections reduction(task, + \
+                                        : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp parallel sections reduction(task,+ : m)…
{
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}} 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}}
} }

clang/test/OpenMP/sections_ast_print.cpp

// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -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 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp-simd -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=50 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
void foo() {} void foo() {}
template <class T, int N> template <class T, int N>
T tmain(T argc) { T tmain(T argc) {
T b = argc, c, d, e, f, g; T b = argc, c, d, e, f, g;
static T a; static T a;
// CHECK: static T a; // CHECK: static T a;
#pragma omp parallel #pragma omp parallel
#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(- : g) nowait allocate(d) #pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(task, - : g) nowait allocate(d)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(task, - : g) nowait allocate(d)
+#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(task, - \
+                                                                                       : g) nowait allocate(d)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp sections private(argc, b), firstprivate…
{ {
foo(); foo();
} }
// CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: #pragma omp parallel
// CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(-: g) nowait allocate(d){{$}} // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(task, -: g) nowait allocate(d){{$}}
// CHECK-NEXT: { // CHECK-NEXT: {
// CHECK-NEXT: foo(); // CHECK-NEXT: foo();
// CHECK-NEXT: } // CHECK-NEXT: }
return T(); return T();
} }
int main(int argc, char **argv) { int main(int argc, char **argv) {
// CHECK: int main(int argc, char **argv) { // CHECK: int main(int argc, char **argv) {
Show All 23 Lines

clang/test/OpenMP/sections_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp parallel #pragma omp parallel
#pragma omp sections reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp sections reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
{ {
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
▲ Show 20 Lines • Show All 429 Lines • ▼ Show 20 Lines#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}}
{ {
foo(); foo();
} }
static int m; static int m;
#pragma omp sections reduction(+ : m) // OK #pragma omp sections reduction(+ : m) // OK
{ {
foo(); foo();
} }
#pragma omp sections reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp sections reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp sections reduction(task, + \
+                               : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp sections reduction(task, + : m) //…
{
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}} 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}}
} }

clang/test/OpenMP/simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
} }
▲ Show 20 Lines • Show All 304 Lines • ▼ Show 20 Lines
#pragma omp parallel private(fl) #pragma omp parallel private(fl)
#pragma omp simd reduction(+ : fl) #pragma omp simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp simd reduction(+ : fl) #pragma omp simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
#pragma omp simd reduction(task, + : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp simd reduction(task, + : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp simd reduction(task, + \
+                           : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp simd reduction(task, + : fl) // omp45…
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}} 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}}
} }

clang/test/OpenMP/target_parallel_ast_print.cpp

// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=45 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=50 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
void foo() {} void foo() {}
template <class T> template <class T>
▲ Show 20 Lines • Show All 202 Lines • ▼ Show 20 Lines// CHECK-NEXT: #pragma omp target parallel nowait
foo(); foo();
// CHECK-NEXT: foo(); // CHECK-NEXT: foo();
#pragma omp target parallel depend(in : argc, argv[i:argc], a[:]) #pragma omp target parallel depend(in : argc, argv[i:argc], a[:])
// CHECK-NEXT: #pragma omp target parallel depend(in : argc,argv[i:argc],a[:]) // CHECK-NEXT: #pragma omp target parallel depend(in : argc,argv[i:argc],a[:])
foo(); foo();
// CHECK-NEXT: foo(); // CHECK-NEXT: foo();
#pragma omp target parallel defaultmap(tofrom: scalar) #pragma omp target parallel defaultmap(tofrom: scalar) reduction(task, +:argc)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target parallel defaultmap(tofrom: scalar) reduction(task, +:argc)
-// CHECK-NEXT: #pragma omp target parallel defaultmap(tofrom: scalar) reduction(task, +: argc)
+#pragma omp target parallel defaultmap(tofrom                      \
+                                       : scalar) reduction(task, + \
+                                                           : argc)
+  // CHECK-NEXT: #pragma omp target parallel defaultmap(tofrom: scalar) reduction(task, +: argc)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target parallel defaultmap(tofrom…
// CHECK-NEXT: #pragma omp target parallel defaultmap(tofrom: scalar) // CHECK-NEXT: #pragma omp target parallel defaultmap(tofrom: scalar) reduction(task, +: argc)
foo(); foo();
// CHECK-NEXT: foo(); // CHECK-NEXT: foo();
return tmain<int, 5>(argc, &argc) + tmain<char, 1>(argv[0][0], argv[0]); return tmain<int, 5>(argc, &argc) + tmain<char, 1>(argv[0][0], argv[0]);
} }
extern template int S<int>::TS; extern template int S<int>::TS;
extern template char S<char>::TS; extern template char S<char>::TS;
#endif #endif

clang/test/OpenMP/target_parallel_for_ast_print.cpp

Show First 20 Lines • Show All 239 Lines • ▼ Show 20 Lines// CHECK-NEXT: #pragma omp target parallel for nowait
for (int i = 0; i < 2; ++i) {} for (int i = 0; i < 2; ++i) {}
// CHECK-NEXT: for (int i = 0; i < 2; ++i) { // CHECK-NEXT: for (int i = 0; i < 2; ++i) {
// CHECK-NEXT: } // CHECK-NEXT: }
#pragma omp target parallel for depend(in : argc, arr[i:argc], arr1[:]) #pragma omp target parallel for depend(in : argc, arr[i:argc], arr1[:])
// CHECK-NEXT: #pragma omp target parallel for depend(in : argc,arr[i:argc],arr1[:]) // CHECK-NEXT: #pragma omp target parallel for depend(in : argc,arr[i:argc],arr1[:])
for (int i = 0; i < 2; ++i) {} for (int i = 0; i < 2; ++i) {}
// CHECK-NEXT: for (int i = 0; i < 2; ++i) { // CHECK-NEXT: for (int i = 0; i < 2; ++i) {
// CHECK-NEXT: } // CHECK-NEXT: }
#pragma omp target parallel for defaultmap(tofrom: scalar) #pragma omp target parallel for defaultmap(tofrom: scalar) reduction(task, +: argc)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target parallel for defaultmap(tofrom: scalar) reduction(task, +: argc)
-// CHECK-NEXT: #pragma omp target parallel for defaultmap(tofrom: scalar) reduction(task, +: argc)
+#pragma omp target parallel for defaultmap(tofrom                      \
+                                           : scalar) reduction(task, + \
+                                                               : argc)
+  // CHECK-NEXT: #pragma omp target parallel for defaultmap(tofrom: scalar) reduction(task, +: argc)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target parallel for defaultmap(tofrom…
// CHECK-NEXT: #pragma omp target parallel for defaultmap(tofrom: scalar) // CHECK-NEXT: #pragma omp target parallel for defaultmap(tofrom: scalar) reduction(task, +: argc)
for (int i = 0; i < 2; ++i) {} for (int i = 0; i < 2; ++i) {}
// CHECK-NEXT: for (int i = 0; i < 2; ++i) { // CHECK-NEXT: for (int i = 0; i < 2; ++i) {
// CHECK-NEXT: } // CHECK-NEXT: }
return (tmain<int, 5>(argc, &argc) + tmain<char, 1>(argv[0][0], argv[0])); return (tmain<int, 5>(argc, &argc) + tmain<char, 1>(argv[0][0], argv[0]));
} }
#endif #endif

clang/test/OpenMP/target_parallel_for_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 310 Lines • ▼ Show 20 Lines
#pragma omp parallel private(fl) #pragma omp parallel private(fl)
#pragma omp target parallel for reduction(+ : fl) #pragma omp target parallel for reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp target parallel for reduction(+ : fl) #pragma omp target parallel for reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
#pragma omp target parallel for reduction(task, + : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target parallel for reduction(task, + : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp target parallel for reduction(task, + \
+                                          : fl) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target parallel for reduction(task, +…
for (int i = 0; i < 10; ++i)
foo();
static int m; static int m;
#pragma omp target parallel for allocate(omp_thread_mem_alloc: m) reduction(+ : m) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'target parallel for' directive}} #pragma omp target parallel for allocate(omp_thread_mem_alloc: m) reduction(+ : m) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'target parallel for' directive}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
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}} 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}}
} }

clang/test/OpenMP/target_parallel_for_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 314 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp target parallel for simd reduction(+ : fl) #pragma omp target parallel for simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp target parallel for simd reduction(+ : m) // OK #pragma omp target parallel for simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp target parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp target parallel for simd reduction(task, + \
+                                               : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target parallel for simd reduction(task…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/target_parallel_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 Lines
#pragma omp for reduction(- : fl) #pragma omp for reduction(- : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
{} {}
#pragma omp target parallel reduction(+ : fl) #pragma omp target parallel reduction(+ : fl)
foo(); foo();
static int m; static int m;
#pragma omp target parallel reduction(+ : m) // OK #pragma omp target parallel reduction(+ : m) // OK
m++; m++;
#pragma omp target parallel reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target parallel reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+#pragma omp target parallel reduction(task, + \
+                                      : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target parallel reduction(task, + : m)…
m++;
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}} 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}}
} }

clang/test/OpenMP/target_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 257 Lines • ▼ Show 20 Lines
#pragma omp parallel #pragma omp parallel
#pragma omp for reduction(- : fl) #pragma omp for reduction(- : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
#pragma omp target reduction(+ : fl) #pragma omp target reduction(+ : fl)
foo(); foo();
static int m; static int m;
#pragma omp target reduction(+ : m) // OK #pragma omp target reduction(+ : m) // OK
m++; m++;
#pragma omp target reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp target reduction(task, + \
+                             : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target reduction(task, + : m) // omp45…
m++;
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}} 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}}
} }

clang/test/OpenMP/target_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 314 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp target simd reduction(+ : fl) #pragma omp target simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp target simd reduction(+ : m) // OK #pragma omp target simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp target simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp target simd reduction(task, + \
+                                  : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target simd reduction(task, + : m) //…
for (int i = 0; i < 10; ++i)
m++;
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}} 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}}
} }

clang/test/OpenMP/target_teams_distribute_parallel_for_ast_print.cpp

Show First 20 Lines • Show All 159 Lines • ▼ Show 20 Lines
// CHECK-NEXT: for (int i = 0; i < 10; ++i) // CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: foo(); // CHECK-NEXT: foo();
#pragma omp target teams distribute parallel for default(none), private(b) firstprivate(argc) shared(d) reduction(+:c) reduction(max:e) num_teams(f) thread_limit(d) #pragma omp target teams distribute parallel for default(none), private(b) firstprivate(argc) shared(d) reduction(+:c) reduction(max:e) num_teams(f) thread_limit(d)
for (int k = 0; k < 10; ++k) for (int k = 0; k < 10; ++k)
e += d + argc; e += d + argc;
// CHECK: #pragma omp target teams distribute parallel for default(none) private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d) // CHECK: #pragma omp target teams distribute parallel for default(none) private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d)
// CHECK-NEXT: for (int k = 0; k < 10; ++k) // CHECK-NEXT: for (int k = 0; k < 10; ++k)
// CHECK-NEXT: e += d + argc; // CHECK-NEXT: e += d + argc;
#pragma omp target teams distribute parallel for #pragma omp target teams distribute parallel for reduction(task,+:argc)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target teams distribute parallel for reduction(task,+:argc)
+#pragma omp target teams distribute parallel for reduction(task, + \
+                                                           : argc)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target teams distribute parallel for…
for (int k = 0; k < 10; ++k) for (int k = 0; k < 10; ++k)
e += d + argc; e += d + argc;
// CHECK: #pragma omp target teams distribute parallel for // CHECK: #pragma omp target teams distribute parallel for reduction(task, +: argc)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-// CHECK: #pragma omp target teams distribute parallel for reduction(task, +: argc)
-// CHECK-NEXT: for (int k = 0; k < 10; ++k)
-// CHECK-NEXT: e += d + argc;
+  // CHECK: #pragma omp target teams distribute parallel for reduction(task, +: argc)
+  // CHECK-NEXT: for (int k = 0; k < 10; ++k)
+  // CHECK-NEXT: e += d + argc;
Lint: Pre-merge checks: clang-format: please reformat the code ``` -// CHECK: #pragma omp target teams distribute…
// CHECK-NEXT: for (int k = 0; k < 10; ++k) // CHECK-NEXT: for (int k = 0; k < 10; ++k)
// CHECK-NEXT: e += d + argc; // CHECK-NEXT: e += d + argc;
return (0); return (0);
} }
#endif #endif

clang/test/OpenMP/target_teams_distribute_parallel_for_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(min : i) #pragma omp parallel reduction(min : i)
#pragma omp target teams distribute parallel for reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} #pragma omp target teams distribute parallel for reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for reduction(+ : fl) #pragma omp target teams distribute parallel for reduction(+ : fl)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target teams distribute parallel for reduction(+ : m) // OK #pragma omp target teams distribute parallel for reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target teams distribute parallel for reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp target teams distribute parallel for reduction(task, + \
+                                                           : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target teams distribute parallel for…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(min : i) #pragma omp parallel reduction(min : i)
#pragma omp target teams distribute parallel for simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} #pragma omp target teams distribute parallel for simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd allocate(omp_thread_mem_alloc: fl) reduction(+ : fl) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'target teams distribute parallel for simd' directive}} #pragma omp target teams distribute parallel for simd allocate(omp_thread_mem_alloc: fl) reduction(+ : fl) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'target teams distribute parallel for simd' directive}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target teams distribute parallel for simd reduction(+ : m) // OK #pragma omp target teams distribute parallel for simd reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target teams distribute parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp target teams distribute parallel for simd reduction(task, + \
+                                                                : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target teams distribute parallel for…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/target_teams_distribute_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 241 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(min : i) #pragma omp parallel reduction(min : i)
#pragma omp target teams distribute reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} #pragma omp target teams distribute reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute reduction(+ : fl) #pragma omp target teams distribute reduction(+ : fl)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target teams distribute reduction(+ : m) // OK #pragma omp target teams distribute reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target teams distribute reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp target teams distribute reduction(task, + \
+                                              : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target teams distribute reduction(task…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/target_teams_distribute_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(min : i) #pragma omp parallel reduction(min : i)
#pragma omp target teams distribute simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} #pragma omp target teams distribute simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute simd reduction(+ : fl) #pragma omp target teams distribute simd reduction(+ : fl)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target teams distribute simd reduction(+ : m) // OK #pragma omp target teams distribute simd reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target teams distribute simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target teams distribute simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp target teams distribute simd reduction(task, + \
+                                                   : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target teams distribute simd reduction…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/target_teams_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 261 Lines • ▼ Show 20 Lines
#pragma omp parallel for reduction(- : fl) #pragma omp parallel for reduction(- : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
{} {}
#pragma omp target teams reduction(+ : fl) #pragma omp target teams reduction(+ : fl)
foo(); foo();
static int m; static int m;
#pragma omp target teams reduction(+ : m) // OK #pragma omp target teams reduction(+ : m) // OK
foo(); foo();
#pragma omp target teams reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp target teams reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp target teams reduction(task, + \
+                                   : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp target teams reduction(task, + : m) //…
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}} 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}}
} }

clang/test/OpenMP/taskloop_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp taskloop reduction(+ : fl) #pragma omp taskloop reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp taskloop reduction(+ : m) // OK #pragma omp taskloop reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp taskloop reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp taskloop reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp taskloop reduction(task, + \
+                               : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp taskloop reduction(task, + : m) //…
for (int i = 0; i < 10; ++i)
m++;
#pragma omp taskloop nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}} #pragma omp taskloop nogroup reduction(+ : m) // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
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}} 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}}
} }

clang/test/OpenMP/taskloop_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
typedef void **omp_allocator_handle_t; typedef void **omp_allocator_handle_t;
extern const omp_allocator_handle_t omp_default_mem_alloc; extern const omp_allocator_handle_t omp_default_mem_alloc;
extern const omp_allocator_handle_t omp_large_cap_mem_alloc; extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
extern const omp_allocator_handle_t omp_const_mem_alloc; extern const omp_allocator_handle_t omp_const_mem_alloc;
extern const omp_allocator_handle_t omp_high_bw_mem_alloc; extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
extern const omp_allocator_handle_t omp_low_lat_mem_alloc; extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
extern const omp_allocator_handle_t omp_cgroup_mem_alloc; extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
#pragma omp parallel reduction(* : fl) #pragma omp parallel reduction(* : fl)
#pragma omp taskloop simd reduction(+ : fl) #pragma omp taskloop simd reduction(+ : fl)
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
foo(); foo();
static int m; static int m;
#pragma omp taskloop simd reduction(+ : m) // OK #pragma omp taskloop simd reduction(+ : m) // OK
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
#pragma omp taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp taskloop simd reduction(task, + \
+                                    : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp taskloop simd reduction(task, + : m) //…
for (int i = 0; i < 10; ++i)
m++;
#pragma omp taskloop simd reduction(+ : m) nogroup // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}} #pragma omp taskloop simd reduction(+ : m) nogroup // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
m++; m++;
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}} 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}}
} }

clang/test/OpenMP/teams_distribute_parallel_for_ast_print.cpp

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Lines
#pragma omp teams distribute parallel for default(none), private(b) firstprivate(argc) shared(d) reduction(+:c) reduction(max:e) num_teams(f) thread_limit(d) copyin(x) #pragma omp teams distribute parallel for default(none), private(b) firstprivate(argc) shared(d) reduction(+:c) reduction(max:e) num_teams(f) thread_limit(d) copyin(x)
for (int k = 0; k < 10; ++k) for (int k = 0; k < 10; ++k)
e += d + argc; e += d + argc;
// CHECK: #pragma omp target // CHECK: #pragma omp target
// CHECK-NEXT: #pragma omp teams distribute parallel for default(none) private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d) copyin(x) // CHECK-NEXT: #pragma omp teams distribute parallel for default(none) private(b) firstprivate(argc) shared(d) reduction(+: c) reduction(max: e) num_teams(f) thread_limit(d) copyin(x)
// CHECK-NEXT: for (int k = 0; k < 10; ++k) // CHECK-NEXT: for (int k = 0; k < 10; ++k)
// CHECK-NEXT: e += d + argc; // CHECK-NEXT: e += d + argc;
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for #pragma omp teams distribute parallel for reduction(task,&&:argc)
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp teams distribute parallel for reduction(task,&&:argc)
+#pragma omp teams distribute parallel for reduction(task, && \
+                                                    : argc)
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp teams distribute parallel for reduction…
for (int k = 0; k < 10; ++k) for (int k = 0; k < 10; ++k)
e += d + argc; e += d + argc;
// CHECK: #pragma omp target // CHECK: #pragma omp target
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-// CHECK: #pragma omp target
-// CHECK-NEXT: #pragma omp teams distribute parallel for reduction(task, &&: argc)
-// CHECK-NEXT: for (int k = 0; k < 10; ++k)
-// CHECK-NEXT: e += d + argc;
+  // CHECK: #pragma omp target
+  // CHECK-NEXT: #pragma omp teams distribute parallel for reduction(task, &&: argc)
+  // CHECK-NEXT: for (int k = 0; k < 10; ++k)
+  // CHECK-NEXT: e += d + argc;
Lint: Pre-merge checks: clang-format: please reformat the code ``` -// CHECK: #pragma omp target -// CHECK-NEXT…
// CHECK-NEXT: #pragma omp teams distribute parallel for // CHECK-NEXT: #pragma omp teams distribute parallel for reduction(task, &&: argc)
// CHECK-NEXT: for (int k = 0; k < 10; ++k) // CHECK-NEXT: for (int k = 0; k < 10; ++k)
// CHECK-NEXT: e += d + argc; // CHECK-NEXT: e += d + argc;
return (0); return (0);
} }
#endif #endif

clang/test/OpenMP/teams_distribute_parallel_for_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp teams distribute parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Lines#pragma omp teams distribute parallel for reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for reduction(+ : fl) #pragma omp teams distribute parallel for reduction(+ : fl)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for reduction(+ : m) // OK #pragma omp teams distribute parallel for reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target
#pragma omp teams distribute parallel for reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp teams distribute parallel for reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp teams distribute parallel for reduction(task, + \
+                                                    : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp teams distribute parallel for reduction…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/teams_distribute_parallel_for_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp teams distribute parallel for simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Lines#pragma omp teams distribute parallel for simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for simd reduction(+ : fl) #pragma omp teams distribute parallel for simd reduction(+ : fl)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams distribute parallel for simd reduction(+ : m) // OK #pragma omp teams distribute parallel for simd reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target
#pragma omp teams distribute parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp teams distribute parallel for simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp teams distribute parallel for simd reduction(task, + \
+                                                         : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp teams distribute parallel for simd…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/teams_distribute_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp target #pragma omp target
#pragma omp teams distribute reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp teams distribute reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 296 Lines • ▼ Show 20 Lines#pragma omp teams distribute reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target #pragma omp target
#pragma omp teams distribute reduction(+ : fl, z) #pragma omp teams distribute reduction(+ : fl, z)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams distribute reduction(+ : m) // OK #pragma omp teams distribute reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target
#pragma omp teams distribute reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp teams distribute reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp teams distribute reduction(task, + \
+                                       : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp teams distribute reduction(task, + : m)…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/teams_distribute_simd_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 %s -Wno-openmp-mapping -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp target #pragma omp target
#pragma omp teams distribute simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp teams distribute simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Lines#pragma omp teams distribute simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target #pragma omp target
#pragma omp teams distribute simd reduction(+ : fl) #pragma omp teams distribute simd reduction(+ : fl)
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams distribute simd reduction(+ : m) // OK #pragma omp teams distribute simd reduction(+ : m) // OK
for (int j=0; j<100; j++) foo(); for (int j=0; j<100; j++) foo();
#pragma omp target
#pragma omp teams distribute simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp teams distribute simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
-  for (int j=0; j<100; j++) foo();
+#pragma omp teams distribute simd reduction(task, + \
+                                            : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+  for (int j = 0; j < 100; j++)
+    foo();
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp teams distribute simd reduction(task, +…
for (int j=0; j<100; j++) 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}} 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}}
} }

clang/test/OpenMP/teams_reduction_messages.cpp

// RUN: %clang_cc1 -verify -fopenmp -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++98 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -o - %s -Wno-openmp-mapping -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -std=c++11 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++98 -o - %s -Wno-openmp-mapping -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -fopenmp-version=50 -std=c++11 -o - %s -Wno-openmp-mapping -Wuninitialized
extern int omp_default_mem_alloc; extern int omp_default_mem_alloc;
void xxx(int argc) { void xxx(int argc) {
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}} int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
#pragma omp target #pragma omp target
#pragma omp teams reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}} #pragma omp teams reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
for (int i = 0; i < 10; ++i) for (int i = 0; i < 10; ++i)
; ;
▲ Show 20 Lines • Show All 322 Lines • ▼ Show 20 Lines#pragma omp parallel for reduction(- : fl)
{} {}
#pragma omp target #pragma omp target
#pragma omp teams reduction(+ : fl) #pragma omp teams reduction(+ : fl)
foo(); foo();
static int m; static int m;
#pragma omp target #pragma omp target
#pragma omp teams reduction(+ : m) // OK #pragma omp teams reduction(+ : m) // OK
foo(); foo();
#pragma omp target
#pragma omp teams reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-#pragma omp teams reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
+#pragma omp teams reduction(task, + \
+                            : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
Lint: Pre-merge checks: clang-format: please reformat the code ``` -#pragma omp teams reduction(task, + : m) // omp45…
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}} 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}}
} }