2019-07-16 22:51:46 +08:00
|
|
|
// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
|
|
|
|
// CHECK-LABEL: void xxx(int argc)
|
|
|
|
void xxx(int argc) {
|
|
|
|
// CHECK: [B1]
|
|
|
|
// CHECK-NEXT: 1: int x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: 2: int cond;
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: 3: int fp;
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-NEXT: 4: int rd;
|
2019-08-08 21:42:45 +08:00
|
|
|
// CHECK-NEXT: 5: int lin;
|
|
|
|
// CHECK-NEXT: 6: int step;
|
2019-08-28 22:55:08 +08:00
|
|
|
// CHECK-NEXT: 7: int map;
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#ATOM:]]: x
|
|
|
|
// CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#ATOM+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
|
|
|
|
// CHECK-NEXT: [[#ATOM+4]]: #pragma omp atomic read
|
|
|
|
// CHECK-NEXT: [B1.[[#ATOM+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp atomic read
|
|
|
|
argc = x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#CRIT:]]: x
|
|
|
|
// CHECK-NEXT: [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#CRIT+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]
|
|
|
|
// CHECK-NEXT: [[#CRIT+4]]: #pragma omp critical
|
|
|
|
// CHECK-NEXT: [B1.[[#CRIT+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp critical
|
|
|
|
argc = x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#MASTER:]]: x
|
|
|
|
// CHECK-NEXT: [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#MASTER+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
|
|
|
|
// CHECK-NEXT: [[#MASTER+4]]: #pragma omp master
|
|
|
|
// CHECK-NEXT: [B1.[[#MASTER+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp master
|
|
|
|
argc = x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#PAR:]]: x
|
|
|
|
// CHECK-NEXT: [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#PAR+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
|
|
|
|
// CHECK-NEXT: [[#PAR+4]]: cond
|
|
|
|
// CHECK-NEXT: [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#PAR+7]]: fp
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-NEXT: [[#PAR+8]]: rd
|
|
|
|
// CHECK-NEXT: [[#PAR+9]]: #pragma omp parallel if(cond) firstprivate(fp) reduction(min: rd)
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [B1.[[#PAR+3]]];
|
2019-07-26 22:50:05 +08:00
|
|
|
#pragma omp parallel if(cond) firstprivate(fp) reduction(min:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
argc = x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#PSECT:]]: x
|
|
|
|
// CHECK-NEXT: [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#PSECT+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
|
|
|
|
// CHECK-NEXT: [[#PSECT+4]]: cond
|
|
|
|
// CHECK-NEXT: [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#PSECT+7]]: fp
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-NEXT: [[#PSECT+8]]: rd
|
|
|
|
// CHECK-NEXT: [[#PSECT+9]]: #pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&: rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
// CHECK-NEXT: {
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [B1.[[#PSECT+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
// CHECK-NEXT: }
|
2019-07-26 22:50:05 +08:00
|
|
|
#pragma omp parallel sections if(cond) firstprivate(fp) reduction(&&:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
{
|
|
|
|
argc = x;
|
|
|
|
}
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#SINGLE:]]: x
|
|
|
|
// CHECK-NEXT: [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#SINGLE+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
|
|
|
|
// CHECK-NEXT: [[#SINGLE+4]]: #pragma omp single
|
|
|
|
// CHECK-NEXT: [B1.[[#SINGLE+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp single
|
|
|
|
argc = x;
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TARGET:]]:
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-SAME: [B1.[[#TARGET+10]]]
|
|
|
|
// CHECK-NEXT: [[#TARGET+1]]: [B1.[[#TARGET+10]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TARGET+2]]: [B1.[[#TARGET+9]]]
|
|
|
|
// CHECK-NEXT: [[#TARGET+3]]: [B1.[[#TARGET+9]]] = [B1.[[#TARGET+1]]]
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#TARGET+4]]: cond
|
|
|
|
// CHECK-NEXT: [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TARGET+7]]: fp
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-NEXT: [[#TARGET+8]]: rd
|
|
|
|
// CHECK-NEXT: [[#TARGET+9]]: argc
|
|
|
|
// CHECK-NEXT: [[#TARGET+10]]: x
|
|
|
|
// CHECK-NEXT: [[#TARGET+11]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp) reduction(-: rd)
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [B1.[[#TARGET+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp target depend(in \
|
2019-07-26 22:50:05 +08:00
|
|
|
: argc) if(cond) firstprivate(fp) reduction(-:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
argc = x;
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TP:]]:
|
2019-08-28 22:55:08 +08:00
|
|
|
// CHECK-SAME: [B1.[[#TP+11]]]
|
|
|
|
// CHECK-NEXT: [[#TP+1]]: [B1.[[#TP+11]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TP+2]]: [B1.[[#TP+10]]]
|
|
|
|
// CHECK-NEXT: [[#TP+3]]: [B1.[[#TP+10]]] = [B1.[[#TP+1]]]
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#TP+4]]: cond
|
|
|
|
// CHECK-NEXT: [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TP+7]]: fp
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-NEXT: [[#TP+8]]: rd
|
2019-08-28 22:55:08 +08:00
|
|
|
// CHECK-NEXT: [[#TP+9]]: map
|
|
|
|
// CHECK-NEXT: [[#TP+10]]: argc
|
|
|
|
// CHECK-NEXT: [[#TP+11]]: x
|
|
|
|
// CHECK-NEXT: [[#TP+12]]: #pragma omp target parallel if(cond) firstprivate(fp) reduction(+: rd) map(to: map)
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [B1.[[#TP+3]]];
|
2019-08-28 22:55:08 +08:00
|
|
|
#pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd) map(to:map)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
argc = x;
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TT:]]:
|
2019-08-28 22:55:08 +08:00
|
|
|
// CHECK-SAME: [B1.[[#TT+11]]]
|
|
|
|
// CHECK-NEXT: [[#TT+1]]: [B1.[[#TT+11]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TT+2]]: [B1.[[#TT+10]]]
|
|
|
|
// CHECK-NEXT: [[#TT+3]]: [B1.[[#TT+10]]] = [B1.[[#TT+1]]]
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#TT+4]]: cond
|
|
|
|
// CHECK-NEXT: [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TT+7]]: fp
|
2019-07-26 22:50:05 +08:00
|
|
|
// CHECK-NEXT: [[#TT+8]]: rd
|
2019-08-28 22:55:08 +08:00
|
|
|
// CHECK-NEXT: [[#TT+9]]: map
|
|
|
|
// CHECK-NEXT: [[#TT+10]]: argc
|
|
|
|
// CHECK-NEXT: [[#TT+11]]: x
|
|
|
|
// CHECK-NEXT: [[#TT+12]]: #pragma omp target teams if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [B1.[[#TT+3]]];
|
2019-08-28 22:55:08 +08:00
|
|
|
#pragma omp target teams if(cond) firstprivate(fp) reduction(+:rd) map(tofrom:map)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
argc = x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#TU:]]: cond
|
|
|
|
// CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
|
|
|
|
#pragma omp target update to(x) if(target update:cond)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TASK:]]:
|
|
|
|
// CHECK-SAME: [B1.[[#TASK+9]]]
|
|
|
|
// CHECK-NEXT: [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TASK+2]]: [B1.[[#TASK+8]]]
|
|
|
|
// CHECK-NEXT: [[#TASK+3]]: [B1.[[#TASK+8]]] = [B1.[[#TASK+1]]]
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#TASK+4]]: cond
|
|
|
|
// CHECK-NEXT: [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2019-07-22 21:51:07 +08:00
|
|
|
// CHECK-NEXT: [[#TASK+7]]: fp
|
|
|
|
// CHECK-NEXT: [[#TASK+8]]: argc
|
|
|
|
// CHECK-NEXT: [[#TASK+9]]: x
|
|
|
|
// CHECK-NEXT: [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [B1.[[#TASK+3]]];
|
2019-07-22 21:51:07 +08:00
|
|
|
#pragma omp task if(cond) firstprivate(fp)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
argc = x;
|
2019-07-16 22:51:46 +08:00
|
|
|
// CHECK-NEXT: [[#TG:]]: x
|
|
|
|
// CHECK-NEXT: [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TG+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
|
|
|
|
// CHECK-NEXT: [[#TG+4]]: #pragma omp taskgroup
|
|
|
|
// CHECK-NEXT: [B1.[[#TG+3]]];
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp taskgroup
|
|
|
|
argc = x;
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-NEXT: [[#TEAMS:]]: x
|
|
|
|
// CHECK-NEXT: [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-NEXT: [[#TEAMS+2]]: argc
|
|
|
|
// CHECK-NEXT: [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]
|
|
|
|
// CHECK-NEXT: [[#TEAMS+4]]: [B1.[[#TEAMS+7]]]
|
|
|
|
// CHECK-NEXT: [[#TEAMS+5]]: [B1.[[#TEAMS+8]]]
|
|
|
|
// CHECK-NEXT: [[#TEAMS+6]]: #pragma omp teams firstprivate(fp) reduction(+: rd)
|
|
|
|
// CHECK-NEXT: [B1.[[#TEAMS+3]]];
|
|
|
|
// CHECK-NEXT: [[#TEAMS+7]]: fp
|
|
|
|
// CHECK-NEXT: [[#TEAMS+8]]: rd
|
|
|
|
// CHECK-NEXT: [[#TEAMS+9]]: argc
|
|
|
|
// CHECK-NEXT: [[#TEAMS+10]]: x
|
|
|
|
// CHECK-NEXT: [[#TEAMS+11]]: #pragma omp target
|
|
|
|
#pragma omp target
|
|
|
|
#pragma omp teams firstprivate(fp) reduction(+:rd)
|
|
|
|
argc = x;
|
|
|
|
// CHECK-NEXT: [B1.[[#TEAMS+6]]] Preds
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void dpf(int argc)
|
|
|
|
void dpf(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#DPFB:]]: x
|
|
|
|
// CHECK-DAG: [[#DPFB+1]]: [B3.[[#DPFB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#DPFB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#DPFB+3]]: [B3.[[#DPFB+2]]] = [B3.[[#DPFB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#DPF:]]: cond
|
|
|
|
// CHECK-DAG: [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#DPF+2]]: [B1.[[#DPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#DPF+3]]: fp
|
|
|
|
// CHECK-DAG: [[#DPF+4]]: rd
|
|
|
|
// CHECK-DAG: [[#DPF+5]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp) reduction(+: rd)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#DPFB+3]]];
|
|
|
|
#pragma omp distribute parallel for if(parallel:cond) firstprivate(fp) reduction(+:rd)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void dpfs(int argc)
|
|
|
|
void dpfs(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#DPFSB:]]: x
|
|
|
|
// CHECK-DAG: [[#DPFSB+1]]: [B3.[[#DPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#DPFSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#DPFSB+3]]: [B3.[[#DPFSB+2]]] = [B3.[[#DPFSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#DPFS:]]: cond
|
|
|
|
// CHECK-DAG: [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#DPFS+2]]: [B1.[[#DPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#DPFS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#DPFS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#DPFS+5]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-: rd)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#DPFSB+3]]];
|
|
|
|
#pragma omp distribute parallel for simd if(cond) firstprivate(fp) reduction(-:rd)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ds(int argc)
|
|
|
|
void ds(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#DSB:]]: x
|
|
|
|
// CHECK-DAG: [[#DSB+1]]: [B3.[[#DSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#DSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#DSB+3]]: [B3.[[#DSB+2]]] = [B3.[[#DSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#DS:]]: #pragma omp distribute simd
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#DSB+3]]];
|
|
|
|
#pragma omp distribute simd
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void for_fn(int argc)
|
|
|
|
void for_fn(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#FORB:]]: x
|
|
|
|
// CHECK-DAG: [[#FORB+1]]: [B3.[[#FORB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#FORB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#FORB+3]]: [B3.[[#FORB+2]]] = [B3.[[#FORB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#FOR:]]: lin
|
|
|
|
// CHECK-DAG: [[#FOR+1]]: step
|
|
|
|
// CHECK-DAG: [[#FOR+2]]: [B1.[[#FOR+1]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#FOR+3]]: #pragma omp for linear(lin: step)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#FORB+3]]];
|
|
|
|
#pragma omp for linear(lin : step)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void fs(int argc)
|
|
|
|
void fs(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#FSB:]]: x
|
|
|
|
// CHECK-DAG: [[#FSB+1]]: [B3.[[#FSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#FSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#FSB+3]]: [B3.[[#FSB+2]]] = [B3.[[#FSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#FS:]]: lin
|
|
|
|
// CHECK-DAG: [[#FS+1]]: step
|
|
|
|
// CHECK-DAG: [[#FS+2]]: [B1.[[#FS+1]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#FS+3]]: #pragma omp for simd linear(lin: step)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#FSB+3]]];
|
|
|
|
#pragma omp for simd linear(lin: step)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ord(int argc)
|
|
|
|
void ord(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#ORDB:]]: x
|
|
|
|
// CHECK-DAG: [[#ORDB+1]]: [B3.[[#ORDB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#ORDB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#ORDB+3]]: [B3.[[#ORDB+2]]] = [B3.[[#ORDB+1]]]
|
|
|
|
// CHECK-DAG: [[#ORDB+4]]: #pragma omp ordered
|
|
|
|
// CHECK-DAG: [B3.[[#ORDB+3]]];
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#ORD:]]: #pragma omp for ordered
|
|
|
|
// CHECK-DAG: for (int i = 0
|
|
|
|
// CHECK-DAG:[B3.[[#ORDB+4]]] }
|
|
|
|
#pragma omp for ordered
|
|
|
|
for (int i = 0; i < 10; ++i) {
|
|
|
|
#pragma omp ordered
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void pf(int argc)
|
|
|
|
void pf(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#PFB:]]: x
|
|
|
|
// CHECK-DAG: [[#PFB+1]]: [B3.[[#PFB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#PFB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#PFB+3]]: [B3.[[#PFB+2]]] = [B3.[[#PFB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#PF:]]: cond
|
|
|
|
// CHECK-DAG: [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#PF+2]]: [B1.[[#PF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#PF+3]]: fp
|
|
|
|
// CHECK-DAG: [[#PF+4]]: rd
|
|
|
|
// CHECK-DAG: [[#PF+5]]: lin
|
|
|
|
// CHECK-DAG: [[#PF+6]]: step
|
|
|
|
// CHECK-DAG: [[#PF+7]]: [B1.[[#PF+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#PF+8]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#PFB+3]]];
|
|
|
|
#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void pfs(int argc)
|
|
|
|
void pfs(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#PFSB:]]: x
|
|
|
|
// CHECK-DAG: [[#PFSB+1]]: [B3.[[#PFSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#PFSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#PFSB+3]]: [B3.[[#PFSB+2]]] = [B3.[[#PFSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#PFS:]]: cond
|
|
|
|
// CHECK-DAG: [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#PFS+2]]: [B1.[[#PFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#PFS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#PFS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#PFS+5]]: lin
|
|
|
|
// CHECK-DAG: [[#PFS+6]]: step
|
|
|
|
// CHECK-DAG: [[#PFS+7]]: [B1.[[#PFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#PFS+8]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#PFSB+3]]];
|
|
|
|
#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void simd(int argc)
|
|
|
|
void simd(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#SIMDB:]]: x
|
|
|
|
// CHECK-DAG: [[#SIMDB+1]]: [B3.[[#SIMDB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#SIMDB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#SIMDB+3]]: [B3.[[#SIMDB+2]]] = [B3.[[#SIMDB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#SIMD:]]: lin
|
|
|
|
// CHECK-DAG: [[#SIMD+1]]: step
|
|
|
|
// CHECK-DAG: [[#SIMD+2]]: [B1.[[#SIMD+1]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#SIMD+3]]: #pragma omp simd linear(lin: step)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#SIMDB+3]]];
|
|
|
|
#pragma omp simd linear(lin: step)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tpf(int argc)
|
|
|
|
void tpf(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TPFB:]]: x
|
|
|
|
// CHECK-DAG: [[#TPFB+1]]: [B3.[[#TPFB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TPFB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TPFB+3]]: [B3.[[#TPFB+2]]] = [B3.[[#TPFB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TPF:]]: cond
|
|
|
|
// CHECK-DAG: [[#TPF+1]]: [B1.[[#TPF]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TPF+2]]: [B1.[[#TPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TPF+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TPF+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TPF+5]]: lin
|
|
|
|
// CHECK-DAG: [[#TPF+6]]: step
|
|
|
|
// CHECK-DAG: [[#TPF+7]]: [B1.[[#TPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TPF+8]]: map
|
|
|
|
// CHECK-DAG: [[#TPF+9]]: [B3.[[#TPFB+2]]]
|
|
|
|
// CHECK-DAG: [[#TPF+10]]: [B3.[[#TPFB]]]
|
|
|
|
// CHECK-DAG: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step) map(tofrom: map)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TPFB+3]]];
|
|
|
|
#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step) map(map)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tpfs(int argc)
|
|
|
|
void tpfs(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TPFSB:]]: x
|
|
|
|
// CHECK-DAG: [[#TPFSB+1]]: [B3.[[#TPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TPFSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TPFSB+3]]: [B3.[[#TPFSB+2]]] = [B3.[[#TPFSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TPFS:]]: cond
|
|
|
|
// CHECK-DAG: [[#TPFS+1]]: [B1.[[#TPFS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TPFS+2]]: [B1.[[#TPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TPFS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TPFS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TPFS+5]]: lin
|
|
|
|
// CHECK-DAG: [[#TPFS+6]]: step
|
|
|
|
// CHECK-DAG: [[#TPFS+7]]: [B1.[[#TPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TPFS+8]]: map
|
|
|
|
// CHECK-DAG: [[#TPFS+9]]: [B3.[[#TPFSB+2]]]
|
|
|
|
// CHECK-DAG: [[#TPFS+10]]: [B3.[[#TPFSB]]]
|
|
|
|
// CHECK-DAG: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step) map(tofrom: map)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TPFSB+3]]];
|
|
|
|
#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step) map(tofrom:map)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ts(int argc)
|
|
|
|
void ts(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TSB:]]: x
|
|
|
|
// CHECK-DAG: [[#TSB+1]]: [B3.[[#TSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TSB+3]]: [B3.[[#TSB+2]]] = [B3.[[#TSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TS:]]: cond
|
|
|
|
// CHECK-DAG: [[#TS+1]]: [B1.[[#TS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TS+2]]: [B1.[[#TS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TS+5]]: lin
|
|
|
|
// CHECK-DAG: [[#TS+6]]: step
|
|
|
|
// CHECK-DAG: [[#TS+7]]: [B1.[[#TS+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TS+8]]: [B3.[[#TSB+2]]]
|
|
|
|
// CHECK-DAG: [[#TS+9]]: [B3.[[#TSB]]]
|
|
|
|
// CHECK-DAG: [[#TS+10]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step) map(alloc: map)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TSB+3]]];
|
|
|
|
#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step) map(alloc:map)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ttd(int argc)
|
|
|
|
void ttd(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TTDB:]]: x
|
|
|
|
// CHECK-DAG: [[#TTDB+1]]: [B3.[[#TTDB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TTDB+3]]: [B3.[[#TTDB+2]]] = [B3.[[#TTDB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TTD:]]: cond
|
|
|
|
// CHECK-DAG: [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTD+2]]: [B1.[[#TTD+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TTD+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TTD+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TTD+5]]: [B3.[[#TTDB+2]]]
|
|
|
|
// CHECK-DAG: [[#TTD+6]]: [B3.[[#TTDB]]]
|
2020-04-07 17:18:44 +08:00
|
|
|
// CHECK-DAG: [[#TTD+7]]: #pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TTDB+3]]];
|
2020-04-07 17:18:44 +08:00
|
|
|
#pragma omp target teams distribute if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
|
2019-10-18 04:35:08 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ttdpf(int argc)
|
|
|
|
void ttdpf(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TTDPFB:]]: x
|
|
|
|
// CHECK-DAG: [[#TTDPFB+1]]: [B3.[[#TTDPFB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDPFB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TTDPFB+3]]: [B3.[[#TTDPFB+2]]] = [B3.[[#TTDPFB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TTDPF:]]: cond
|
|
|
|
// CHECK-DAG: [[#TTDPF+1]]: [B1.[[#TTDPF]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDPF+2]]: [B1.[[#TTDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TTDPF+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TTDPF+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TTDPF+5]]: [B3.[[#TTDPFB+2]]]
|
|
|
|
// CHECK-DAG: [[#TTDPF+6]]: [B3.[[#TTDPFB]]]
|
2020-04-07 17:18:44 +08:00
|
|
|
// CHECK-DAG: [[#TTDPF+7]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd) map(alloc: map)
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TTDPFB+3]]];
|
2020-04-07 17:18:44 +08:00
|
|
|
#pragma omp target teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd) map(alloc:map)
|
2019-10-18 04:35:08 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ttdpfs(int argc)
|
|
|
|
void ttdpfs(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TTDPFSB:]]: x
|
|
|
|
// CHECK-DAG: [[#TTDPFSB+1]]: [B3.[[#TTDPFSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDPFSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TTDPFSB+3]]: [B3.[[#TTDPFSB+2]]] = [B3.[[#TTDPFSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TTDPFS:]]: cond
|
|
|
|
// CHECK-DAG: [[#TTDPFS+1]]: [B1.[[#TTDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDPFS+2]]: [B1.[[#TTDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TTDPFS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TTDPFS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TTDPFS+5]]: [B3.[[#TTDPFSB+2]]]
|
|
|
|
// CHECK-DAG: [[#TTDPFS+6]]: [B3.[[#TTDPFSB]]]
|
|
|
|
// CHECK-DAG: [[#TTDPFS+7]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp) reduction(+: rd) map(from: map)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TTDPFSB+3]]];
|
|
|
|
#pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp) reduction(+:rd) map(from:map)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void ttds(int argc)
|
|
|
|
void ttds(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TTDSB:]]: x
|
|
|
|
// CHECK-DAG: [[#TTDSB+1]]: [B3.[[#TTDSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TTDSB+3]]: [B3.[[#TTDSB+2]]] = [B3.[[#TTDSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TTDS:]]: cond
|
|
|
|
// CHECK-DAG: [[#TTDS+1]]: [B1.[[#TTDS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TTDS+2]]: [B1.[[#TTDS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TTDS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TTDS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TTDS+5]]: map
|
|
|
|
// CHECK-DAG: [[#TTDS+6]]: [B3.[[#TTDSB+2]]]
|
|
|
|
// CHECK-DAG: [[#TTDS+7]]: [B3.[[#TTDSB]]]
|
|
|
|
// CHECK-DAG: [[#TTDS+8]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+: rd) map(tofrom: map)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TTDPFSB+3]]];
|
|
|
|
#pragma omp target teams distribute simd if(cond) firstprivate(fp) reduction(+:rd) map(map)
|
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tl(int argc)
|
|
|
|
void tl(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TLB:]]: x
|
|
|
|
// CHECK-DAG: [[#TLB+1]]: [B3.[[#TLB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TLB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TLB+3]]: [B3.[[#TLB+2]]] = [B3.[[#TLB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TL:]]: cond
|
|
|
|
// CHECK-DAG: [[#TL+1]]: [B1.[[#TL]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TL+2]]: [B1.[[#TL+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TL+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TL+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TL+5]]: [B3.[[#TLB+2]]]
|
|
|
|
// CHECK-DAG: [[#TL+6]]: [B3.[[#TLB]]]
|
|
|
|
// CHECK-DAG: [[#TL+7]]: #pragma omp taskloop if(cond) firstprivate(fp) reduction(+: rd)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TLB+3]]];
|
2019-07-26 22:50:05 +08:00
|
|
|
#pragma omp taskloop if(cond) firstprivate(fp) reduction(+:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
2019-10-18 04:35:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tls(int argc)
|
|
|
|
void tls(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TLSB:]]: x
|
|
|
|
// CHECK-DAG: [[#TLSB+1]]: [B3.[[#TLSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TLSB+2]]: argc
|
|
|
|
// CHECK-DAG: [[#TLSB+3]]: [B3.[[#TLSB+2]]] = [B3.[[#TLSB+1]]]
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TLS:]]: cond
|
|
|
|
// CHECK-DAG: [[#TLS+1]]: [B1.[[#TLS]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TLS+2]]: [B1.[[#TLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
|
|
|
// CHECK-DAG: [[#TLS+3]]: fp
|
|
|
|
// CHECK-DAG: [[#TLS+4]]: rd
|
|
|
|
// CHECK-DAG: [[#TLS+5]]: lin
|
|
|
|
// CHECK-DAG: [[#TLS+6]]: step
|
|
|
|
// CHECK-DAG: [[#TLS+7]]: [B1.[[#TLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TLS+8]]: [B3.[[#TLSB+2]]]
|
|
|
|
// CHECK-DAG: [[#TLS+9]]: [B3.[[#TLSB]]]
|
|
|
|
// CHECK-DAG: [[#TLS+10]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TLSB+3]]];
|
2019-08-08 21:42:45 +08:00
|
|
|
#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
2019-10-18 04:35:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tdpf(int argc)
|
|
|
|
void tdpf(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B1]
|
2021-11-25 01:52:46 +08:00
|
|
|
// CHECK-DAG: [[#TDPF:]]: [B1.{{.+}}]
|
|
|
|
// CHECK-DAG: [[#TDPF+1]]: [B1.[[#TDPF+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: [[#TDPF+2]]: [B1.[[#TDPF+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2021-11-25 01:52:46 +08:00
|
|
|
// CHECK-DAG: [[#TDPF+3]]: [B1.[[#TDPF+7]]]
|
|
|
|
// CHECK-DAG: [[#TDPF+4]]: [B1.[[#TDPF+8]]]
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: [[#TDPF+5]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+: rd)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TDPFB:]]];
|
2021-11-25 01:52:46 +08:00
|
|
|
// CHECK-DAG: [[#TDPF+6]]: cond
|
|
|
|
// CHECK-DAG: [[#TDPF+7]]: fp
|
|
|
|
// CHECK-DAG: [[#TDPF+8]]: rd
|
|
|
|
// CHECK-DAG: [[#TDPF+9]]: argc
|
|
|
|
// CHECK-DAG: [[#TDPF+10]]: x
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: [[#TDPF+11]]: #pragma omp target
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TDPFB-3]]: x
|
|
|
|
// CHECK-DAG: [[#TDPFB-2]]: [B3.[[#TDPFB-3]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TDPFB-1]]: argc
|
|
|
|
// CHECK-DAG: [[#TDPFB]]: [B3.[[#TDPFB-1]]] = [B3.[[#TDPFB-2]]]
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp target
|
2019-07-26 22:50:05 +08:00
|
|
|
#pragma omp teams distribute parallel for if(cond) firstprivate(fp) reduction(+:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
2019-10-18 04:35:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tdpfs(int argc)
|
|
|
|
void tdpfs(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B1]
|
2021-11-25 01:52:46 +08:00
|
|
|
// CHECK-DAG: [[#TDPFS:]]: [B1.{{.+}}]
|
|
|
|
// CHECK-DAG: [[#TDPFS+1]]: [B1.[[#TDPFS+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: [[#TDPFS+2]]: [B1.[[#TDPFS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
2021-11-25 01:52:46 +08:00
|
|
|
// CHECK-DAG: [[#TDPFS+3]]: [B1.[[#TDPFS+7]]]
|
|
|
|
// CHECK-DAG: [[#TDPFS+4]]: [B1.[[#TDPFS+8]]]
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: [[#TDPFS+5]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+: rd)
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TDPFSB:]]];
|
2021-11-25 01:52:46 +08:00
|
|
|
// CHECK-DAG: [[#TDPFS+6]]: cond
|
|
|
|
// CHECK-DAG: [[#TDPFS+7]]: fp
|
|
|
|
// CHECK-DAG: [[#TDPFS+8]]: rd
|
|
|
|
// CHECK-DAG: [[#TDPFS+9]]: argc
|
|
|
|
// CHECK-DAG: [[#TDPFS+10]]: x
|
2019-10-18 04:35:08 +08:00
|
|
|
// CHECK-DAG: [[#TDPFS+11]]: #pragma omp target
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TDPFSB-3]]: x
|
|
|
|
// CHECK-DAG: [[#TDPFSB-2]]: [B3.[[#TDPFSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TDPFSB-1]]: argc
|
|
|
|
// CHECK-DAG: [[#TDPFSB]]: [B3.[[#TDPFSB-1]]] = [B3.[[#TDPFSB-2]]]
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp target
|
2019-07-26 22:50:05 +08:00
|
|
|
#pragma omp teams distribute parallel for simd if(cond) firstprivate(fp) reduction(+:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
2019-10-18 04:35:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// CHECK-LABEL: void tds(int argc)
|
|
|
|
void tds(int argc) {
|
|
|
|
int x, cond, fp, rd, lin, step, map;
|
|
|
|
// CHECK-DAG: [B1]
|
|
|
|
// CHECK-DAG: [[#TDS:]]: #pragma omp teams distribute simd firstprivate(fp) reduction(+: rd)
|
|
|
|
// CHECK-DAG: [[#TDS-2]]: [B1.[[#TDS+1]]]
|
|
|
|
// CHECK-DAG: [[#TDS-1]]: [B1.[[#TDS+2]]]
|
|
|
|
// CHECK-DAG: for (int i = 0;
|
|
|
|
// CHECK-DAG: [B3.[[#TDSB:]]];
|
|
|
|
// CHECK-DAG: [[#TDS+1]]: fp
|
|
|
|
// CHECK-DAG: [[#TDS+2]]: rd
|
|
|
|
// CHECK-DAG: [[#TDS+3]]: argc
|
|
|
|
// CHECK-DAG: [[#TDS+4]]: x
|
|
|
|
// CHECK-DAG: [[#TDS+5]]: #pragma omp target
|
|
|
|
// CHECK-DAG: [B3]
|
|
|
|
// CHECK-DAG: [[#TDSB-3]]: x
|
|
|
|
// CHECK-DAG: [[#TDSB-2]]: [B3.[[#TDSB-3]]] (ImplicitCastExpr, LValueToRValue, int)
|
|
|
|
// CHECK-DAG: [[#TDSB-1]]: argc
|
|
|
|
// CHECK-DAG: [[#TDSB]]: [B3.[[#TDSB-1]]] = [B3.[[#TDSB-2]]]
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
#pragma omp target
|
2019-07-26 22:50:05 +08:00
|
|
|
#pragma omp teams distribute simd firstprivate(fp) reduction(+:rd)
|
[OPENMP]Initial fix PR42392: Improve -Wuninitialized warnings for OpenMP programs.
Summary:
Some OpenMP clauses rely on the values of the variables. If the variable
is not initialized and used in OpenMP clauses that depend on the
variables values, it should be reported that the uninitialized variable
is used in the OpenMP clause expression.
This patch adds initial processing for uninitialized variables in OpenMP
constructs. Currently, it checks for use of the uninitialized variables
in the structured blocks.
Reviewers: NoQ, Szelethus, dcoughlin, xazax.hun, a.sidorin, george.karpenkov, szepet
Subscribers: rnkovacs, guansong, jfb, jdoerfert, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D64356
llvm-svn: 365786
2019-07-11 22:54:17 +08:00
|
|
|
for (int i = 0; i < 10; ++i)
|
|
|
|
argc = x;
|
|
|
|
}
|