Skip to content

Commit 195ae90

Browse files
alexey-bataevalexey-bataev
committed
[OPENMP]Add support for analysis of linear variables and step.
Summary: Added support for basic analysis of the linear variables and linear step expression. Linear loop iteration variables must be excluded from this analysis, only non-loop iteration variables must be analyzed. Reviewers: NoQ Subscribers: guansong, cfe-commits, caomhin, kkwli0 Tags: #clang Differential Revision: https://reviews.llvm.org/D65461 llvm-svn: 368295
1 parent c822ab8 commit 195ae90

21 files changed

+252
-53
lines changed

‎clang/include/clang/AST/OpenMPClause.h

Lines changed: 30 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3216,6 +3216,14 @@ class OMPLinearClause final
32163216
return llvm::makeArrayRef(getUpdates().end(), varlist_size());
32173217
}
32183218

3219+
/// Gets the list of used expressions for linear variables.
3220+
MutableArrayRef<Expr *> getUsedExprs() {
3221+
return MutableArrayRef<Expr *>(getFinals().end() + 2, varlist_size() + 1);
3222+
}
3223+
ArrayRef<const Expr *> getUsedExprs() const {
3224+
return llvm::makeArrayRef(getFinals().end() + 2, varlist_size() + 1);
3225+
}
3226+
32193227
/// Sets the list of the copies of original linear variables.
32203228
/// \param PL List of expressions.
32213229
void setPrivates(ArrayRef<Expr *> PL);
@@ -3295,6 +3303,9 @@ class OMPLinearClause final
32953303
/// \param FL List of expressions.
32963304
void setFinals(ArrayRef<Expr *> FL);
32973305

3306+
/// Sets the list of used expressions for the linear clause.
3307+
void setUsedExprs(ArrayRef<Expr *> UE);
3308+
32983309
using privates_iterator = MutableArrayRef<Expr *>::iterator;
32993310
using privates_const_iterator = ArrayRef<const Expr *>::iterator;
33003311
using privates_range = llvm::iterator_range<privates_iterator>;
@@ -3347,6 +3358,21 @@ class OMPLinearClause final
33473358
return finals_const_range(getFinals().begin(), getFinals().end());
33483359
}
33493360

3361+
using used_expressions_iterator = MutableArrayRef<Expr *>::iterator;
3362+
using used_expressions_const_iterator = ArrayRef<const Expr *>::iterator;
3363+
using used_expressions_range =
3364+
llvm::iterator_range<used_expressions_iterator>;
3365+
using used_expressions_const_range =
3366+
llvm::iterator_range<used_expressions_const_iterator>;
3367+
3368+
used_expressions_range used_expressions() {
3369+
return finals_range(getUsedExprs().begin(), getUsedExprs().end());
3370+
}
3371+
3372+
used_expressions_const_range used_expressions() const {
3373+
return finals_const_range(getUsedExprs().begin(), getUsedExprs().end());
3374+
}
3375+
33503376
child_range children() {
33513377
return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
33523378
reinterpret_cast<Stmt **>(varlist_end()));
@@ -3357,11 +3383,11 @@ class OMPLinearClause final
33573383
return const_child_range(Children.begin(), Children.end());
33583384
}
33593385

3360-
child_range used_children() {
3361-
return child_range(child_iterator(), child_iterator());
3362-
}
3386+
child_range used_children();
3387+
33633388
const_child_range used_children() const {
3364-
return const_child_range(const_child_iterator(), const_child_iterator());
3389+
auto Children = const_cast<OMPLinearClause *>(this)->used_children();
3390+
return const_child_range(Children.begin(), Children.end());
33653391
}
33663392

33673393
static bool classof(const OMPClause *T) {

‎clang/lib/AST/OpenMPClause.cpp

Lines changed: 23 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -429,15 +429,23 @@ void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
429429
std::copy(FL.begin(), FL.end(), getUpdates().end());
430430
}
431431

432+
void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
433+
assert(
434+
UE.size() == varlist_size() + 1 &&
435+
"Number of used expressions is not the same as the preallocated buffer");
436+
std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
437+
}
438+
432439
OMPLinearClause *OMPLinearClause::Create(
433440
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
434441
OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
435442
SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
436443
ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
437444
Stmt *PreInit, Expr *PostUpdate) {
438-
// Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
439-
// (Step and CalcStep).
440-
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
445+
// Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
446+
// (Step and CalcStep), list of used expression + step.
447+
void *Mem =
448+
C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
441449
OMPLinearClause *Clause = new (Mem) OMPLinearClause(
442450
StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
443451
Clause->setVarRefs(VL);
@@ -449,6 +457,8 @@ OMPLinearClause *OMPLinearClause::Create(
449457
nullptr);
450458
std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
451459
nullptr);
460+
std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
461+
nullptr);
452462
Clause->setStep(Step);
453463
Clause->setCalcStep(CalcStep);
454464
Clause->setPreInitStmt(PreInit);
@@ -458,12 +468,19 @@ OMPLinearClause *OMPLinearClause::Create(
458468

459469
OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
460470
unsigned NumVars) {
461-
// Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
462-
// (Step and CalcStep).
463-
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
471+
// Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
472+
// (Step and CalcStep), list of used expression + step.
473+
void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars +1));
464474
return new (Mem) OMPLinearClause(NumVars);
465475
}
466476

477+
OMPClause::child_range OMPLinearClause::used_children() {
478+
// Range includes only non-nullptr elements.
479+
return child_range(
480+
reinterpret_cast<Stmt **>(getUsedExprs().begin()),
481+
reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
482+
}
483+
467484
OMPAlignedClause *
468485
OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
469486
SourceLocation LParenLoc, SourceLocation ColonLoc,

‎clang/lib/Sema/SemaOpenMP.cpp

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12724,6 +12724,7 @@ static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1272412724
// Walk the vars and build update/final expressions for the CodeGen.
1272512725
SmallVector<Expr *, 8> Updates;
1272612726
SmallVector<Expr *, 8> Finals;
12727+
SmallVector<Expr *, 8> UsedExprs;
1272712728
Expr *Step = Clause.getStep();
1272812729
Expr *CalcStep = Clause.getCalcStep();
1272912730
// OpenMP [2.14.3.7, linear clause]
@@ -12799,16 +12800,24 @@ static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
1279912800
if (!Update.isUsable() || !Final.isUsable()) {
1280012801
Updates.push_back(nullptr);
1280112802
Finals.push_back(nullptr);
12803+
UsedExprs.push_back(nullptr);
1280212804
HasErrors = true;
1280312805
} else {
1280412806
Updates.push_back(Update.get());
1280512807
Finals.push_back(Final.get());
12808+
if (!Info.first)
12809+
UsedExprs.push_back(SimpleRefExpr);
1280612810
}
1280712811
++CurInit;
1280812812
++CurPrivate;
1280912813
}
12814+
if (Expr *S = Clause.getStep())
12815+
UsedExprs.push_back(S);
12816+
// Fill the remaining part with the nullptr.
12817+
UsedExprs.append(Clause.varlist_size() + 1 - UsedExprs.size(), nullptr);
1281012818
Clause.setUpdates(Updates);
1281112819
Clause.setFinals(Finals);
12820+
Clause.setUsedExprs(UsedExprs);
1281212821
return HasErrors;
1281312822
}
1281412823

‎clang/lib/Serialization/ASTReader.cpp

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12736,6 +12736,10 @@ void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
1273612736
C->setFinals(Vars);
1273712737
C->setStep(Record.readSubExpr());
1273812738
C->setCalcStep(Record.readSubExpr());
12739+
Vars.clear();
12740+
for (unsigned I = 0; I != NumVars + 1; ++I)
12741+
Vars.push_back(Record.readSubExpr());
12742+
C->setUsedExprs(Vars);
1273912743
}
1274012744

1274112745
void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {

‎clang/lib/Serialization/ASTWriter.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6846,6 +6846,8 @@ void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
68466846
}
68476847
Record.AddStmt(C->getStep());
68486848
Record.AddStmt(C->getCalcStep());
6849+
for (auto *VE : C->used_expressions())
6850+
Record.AddStmt(VE);
68496851
}
68506852

68516853
void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {

‎clang/test/Analysis/cfg-openmp.cpp

Lines changed: 72 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,9 @@ void xxx(int argc) {
77
// CHECK-NEXT: 2: int cond;
88
// CHECK-NEXT: 3: int fp;
99
// CHECK-NEXT: 4: int rd;
10-
int x, cond, fp, rd;
10+
// CHECK-NEXT: 5: int lin;
11+
// CHECK-NEXT: 6: int step;
12+
int x, cond, fp, rd, lin, step;
1113
// CHECK-NEXT: [[#ATOM:]]: x
1214
// CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
1315
// CHECK-NEXT: [[#ATOM+2]]: argc
@@ -68,20 +70,26 @@ void xxx(int argc) {
6870
// CHECK-NEXT: [[#FOR+1]]: [B1.[[#FOR]]] (ImplicitCastExpr, LValueToRValue, int)
6971
// CHECK-NEXT: [[#FOR+2]]: argc
7072
// CHECK-NEXT: [[#FOR+3]]: [B1.[[#FOR+2]]] = [B1.[[#FOR+1]]]
71-
// CHECK-NEXT: [[#FOR+4]]: #pragma omp for
73+
// CHECK-NEXT: [[#FOR+4]]: lin
74+
// CHECK-NEXT: [[#FOR+5]]: step
75+
// CHECK-NEXT: [[#FOR+6]]: [B1.[[#FOR+5]]] (ImplicitCastExpr, LValueToRValue, int)
76+
// CHECK-NEXT: [[#FOR+7]]: #pragma omp for linear(lin: step)
7277
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
7378
// CHECK-NEXT: [B1.[[#FOR+3]]];
74-
#pragma omp for
79+
#pragma omp for linear(lin : step)
7580
for (int i = 0; i < 10; ++i)
7681
argc = x;
7782
// CHECK-NEXT: [[#FS:]]: x
7883
// CHECK-NEXT: [[#FS+1]]: [B1.[[#FS]]] (ImplicitCastExpr, LValueToRValue, int)
7984
// CHECK-NEXT: [[#FS+2]]: argc
8085
// CHECK-NEXT: [[#FS+3]]: [B1.[[#FS+2]]] = [B1.[[#FS+1]]]
81-
// CHECK-NEXT: [[#FS+4]]: #pragma omp for simd
86+
// CHECK-NEXT: [[#FS+4]]: lin
87+
// CHECK-NEXT: [[#FS+5]]: step
88+
// CHECK-NEXT: [[#FS+6]]: [B1.[[#FS+5]]] (ImplicitCastExpr, LValueToRValue, int)
89+
// CHECK-NEXT: [[#FS+7]]: #pragma omp for simd linear(lin: step)
8290
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
8391
// CHECK-NEXT: [B1.[[#FS+3]]];
84-
#pragma omp for simd
92+
#pragma omp for simd linear(lin: step)
8593
for (int i = 0; i < 10; ++i)
8694
argc = x;
8795
// CHECK-NEXT: [[#MASTER:]]: x
@@ -115,10 +123,13 @@ void xxx(int argc) {
115123
// CHECK-NEXT: [[#PF+6]]: [B1.[[#PF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
116124
// CHECK-NEXT: [[#PF+7]]: fp
117125
// CHECK-NEXT: [[#PF+8]]: rd
118-
// CHECK-NEXT: [[#PF+9]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd)
126+
// CHECK-NEXT: [[#PF+9]]: lin
127+
// CHECK-NEXT: [[#PF+10]]: step
128+
// CHECK-NEXT: [[#PF+11]]: [B1.[[#PF+10]]] (ImplicitCastExpr, LValueToRValue, int)
129+
// CHECK-NEXT: [[#PF+12]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
119130
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
120131
// CHECK-NEXT: [B1.[[#PF+3]]];
121-
#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd)
132+
#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
122133
for (int i = 0; i < 10; ++i)
123134
argc = x;
124135
// CHECK-NEXT: [[#PFS:]]: x
@@ -130,10 +141,13 @@ void xxx(int argc) {
130141
// CHECK-NEXT: [[#PFS+6]]: [B1.[[#PFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
131142
// CHECK-NEXT: [[#PFS+7]]: fp
132143
// CHECK-NEXT: [[#PFS+8]]: rd
133-
// CHECK-NEXT: [[#PFS+9]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd)
144+
// CHECK-NEXT: [[#PFS+9]]: lin
145+
// CHECK-NEXT: [[#PFS+10]]: step
146+
// CHECK-NEXT: [[#PFS+11]]: [B1.[[#PFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
147+
// CHECK-NEXT: [[#PFS+12]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
134148
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
135149
// CHECK-NEXT: [B1.[[#PFS+3]]];
136-
#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd)
150+
#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
137151
for (int i = 0; i < 10; ++i)
138152
argc = x;
139153
// CHECK-NEXT: [[#PAR:]]: x
@@ -170,10 +184,13 @@ void xxx(int argc) {
170184
// CHECK-NEXT: [[#SIMD+1]]: [B1.[[#SIMD]]] (ImplicitCastExpr, LValueToRValue, int)
171185
// CHECK-NEXT: [[#SIMD+2]]: argc
172186
// CHECK-NEXT: [[#SIMD+3]]: [B1.[[#SIMD+2]]] = [B1.[[#SIMD+1]]]
173-
// CHECK-NEXT: [[#SIMD+4]]: #pragma omp simd
187+
// CHECK-NEXT: [[#SIMD+4]]: lin
188+
// CHECK-NEXT: [[#SIMD+5]]: step
189+
// CHECK-NEXT: [[#SIMD+6]]: [B1.[[#SIMD+5]]] (ImplicitCastExpr, LValueToRValue, int)
190+
// CHECK-NEXT: [[#SIMD+7]]: #pragma omp simd linear(lin: step)
174191
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
175192
// CHECK-NEXT: [B1.[[#SIMD+3]]];
176-
#pragma omp simd
193+
#pragma omp simd linear(lin: step)
177194
for (int i = 0; i < 10; ++i)
178195
argc = x;
179196
// CHECK-NEXT: [[#SINGLE:]]: x
@@ -202,39 +219,45 @@ void xxx(int argc) {
202219
: argc) if(cond) firstprivate(fp) reduction(-:rd)
203220
argc = x;
204221
// CHECK-NEXT: [[#TPF:]]:
205-
// CHECK-SAME: [B1.[[#TPF+10]]]
206-
// CHECK-NEXT: [[#TPF+1]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
207-
// CHECK-NEXT: [[#TPF+2]]: [B1.[[#TPF+9]]]
208-
// CHECK-NEXT: [[#TPF+3]]: [B1.[[#TPF+9]]] = [B1.[[#TPF+1]]]
222+
// CHECK-SAME: [B1.[[#TPF+13]]]
223+
// CHECK-NEXT: [[#TPF+1]]: [B1.[[#TPF+13]]] (ImplicitCastExpr, LValueToRValue, int)
224+
// CHECK-NEXT: [[#TPF+2]]: [B1.[[#TPF+12]]]
225+
// CHECK-NEXT: [[#TPF+3]]: [B1.[[#TPF+12]]] = [B1.[[#TPF+1]]]
209226
// CHECK-NEXT: [[#TPF+4]]: cond
210227
// CHECK-NEXT: [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
211228
// CHECK-NEXT: [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
212229
// CHECK-NEXT: [[#TPF+7]]: fp
213230
// CHECK-NEXT: [[#TPF+8]]: rd
214-
// CHECK-NEXT: [[#TPF+9]]: argc
215-
// CHECK-NEXT: [[#TPF+10]]: x
216-
// CHECK-NEXT: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd)
231+
// CHECK-NEXT: [[#TPF+9]]: lin
232+
// CHECK-NEXT: [[#TPF+10]]: step
233+
// CHECK-NEXT: [[#TPF+11]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
234+
// CHECK-NEXT: [[#TPF+12]]: argc
235+
// CHECK-NEXT: [[#TPF+13]]: x
236+
// CHECK-NEXT: [[#TPF+14]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step)
217237
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
218238
// CHECK-NEXT: [B1.[[#TPF+3]]];
219-
#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd)
239+
#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step)
220240
for (int i = 0; i < 10; ++i)
221241
argc = x;
222242
// CHECK-NEXT: [[#TPFS:]]:
223-
// CHECK-SAME: [B1.[[#TPFS+10]]]
224-
// CHECK-NEXT: [[#TPFS+1]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
225-
// CHECK-NEXT: [[#TPFS+2]]: [B1.[[#TPFS+9]]]
226-
// CHECK-NEXT: [[#TPFS+3]]: [B1.[[#TPFS+9]]] = [B1.[[#TPFS+1]]]
243+
// CHECK-SAME: [B1.[[#TPFS+13]]]
244+
// CHECK-NEXT: [[#TPFS+1]]: [B1.[[#TPFS+13]]] (ImplicitCastExpr, LValueToRValue, int)
245+
// CHECK-NEXT: [[#TPFS+2]]: [B1.[[#TPFS+12]]]
246+
// CHECK-NEXT: [[#TPFS+3]]: [B1.[[#TPFS+12]]] = [B1.[[#TPFS+1]]]
227247
// CHECK-NEXT: [[#TPFS+4]]: cond
228248
// CHECK-NEXT: [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
229249
// CHECK-NEXT: [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
230250
// CHECK-NEXT: [[#TPFS+7]]: fp
231251
// CHECK-NEXT: [[#TPFS+8]]: rd
232-
// CHECK-NEXT: [[#TPFS+9]]: argc
233-
// CHECK-NEXT: [[#TPFS+10]]: x
234-
// CHECK-NEXT: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd)
252+
// CHECK-NEXT: [[#TPFS+9]]: lin
253+
// CHECK-NEXT: [[#TPFS+10]]: step
254+
// CHECK-NEXT: [[#TPFS+11]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
255+
// CHECK-NEXT: [[#TPFS+12]]: argc
256+
// CHECK-NEXT: [[#TPFS+13]]: x
257+
// CHECK-NEXT: [[#TPFS+14]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step)
235258
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
236259
// CHECK-NEXT: [B1.[[#TPFS+3]]];
237-
#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd)
260+
#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step)
238261
for (int i = 0; i < 10; ++i)
239262
argc = x;
240263
// CHECK-NEXT: [[#TP:]]:
@@ -254,21 +277,24 @@ void xxx(int argc) {
254277
#pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd)
255278
argc = x;
256279
// CHECK-NEXT: [[#TSIMD:]]:
257-
// CHECK-SAME: [B1.[[#TSIMD+10]]]
258-
// CHECK-NEXT: [[#TSIMD+1]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
259-
// CHECK-NEXT: [[#TSIMD+2]]: [B1.[[#TSIMD+9]]]
260-
// CHECK-NEXT: [[#TSIMD+3]]: [B1.[[#TSIMD+9]]] = [B1.[[#TSIMD+1]]]
280+
// CHECK-SAME: [B1.[[#TSIMD+13]]]
281+
// CHECK-NEXT: [[#TSIMD+1]]: [B1.[[#TSIMD+13]]] (ImplicitCastExpr, LValueToRValue, int)
282+
// CHECK-NEXT: [[#TSIMD+2]]: [B1.[[#TSIMD+12]]]
283+
// CHECK-NEXT: [[#TSIMD+3]]: [B1.[[#TSIMD+12]]] = [B1.[[#TSIMD+1]]]
261284
// CHECK-NEXT: [[#TSIMD+4]]: cond
262285
// CHECK-NEXT: [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int)
263286
// CHECK-NEXT: [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
264287
// CHECK-NEXT: [[#TSIMD+7]]: fp
265288
// CHECK-NEXT: [[#TSIMD+8]]: rd
266-
// CHECK-NEXT: [[#TSIMD+9]]: argc
267-
// CHECK-NEXT: [[#TSIMD+10]]: x
268-
// CHECK-NEXT: [[#TSIMD+11]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd)
289+
// CHECK-NEXT: [[#TSIMD+9]]: lin
290+
// CHECK-NEXT: [[#TSIMD+10]]: step
291+
// CHECK-NEXT: [[#TSIMD+11]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
292+
// CHECK-NEXT: [[#TSIMD+12]]: argc
293+
// CHECK-NEXT: [[#TSIMD+13]]: x
294+
// CHECK-NEXT: [[#TSIMD+14]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
269295
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
270296
// CHECK-NEXT: [B1.[[#TSIMD+3]]];
271-
#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd)
297+
#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
272298
for (int i = 0; i < 10; ++i)
273299
argc = x;
274300
// CHECK-NEXT: [[#TTD:]]:
@@ -406,21 +432,24 @@ void xxx(int argc) {
406432
for (int i = 0; i < 10; ++i)
407433
argc = x;
408434
// CHECK-NEXT: [[#TLS:]]:
409-
// CHECK-SAME: [B1.[[#TLS+10]]]
410-
// CHECK-NEXT: [[#TLS+1]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
411-
// CHECK-NEXT: [[#TLS+2]]: [B1.[[#TLS+9]]]
412-
// CHECK-NEXT: [[#TLS+3]]: [B1.[[#TLS+9]]] = [B1.[[#TLS+1]]]
435+
// CHECK-SAME: [B1.[[#TLS+13]]]
436+
// CHECK-NEXT: [[#TLS+1]]: [B1.[[#TLS+13]]] (ImplicitCastExpr, LValueToRValue, int)
437+
// CHECK-NEXT: [[#TLS+2]]: [B1.[[#TLS+12]]]
438+
// CHECK-NEXT: [[#TLS+3]]: [B1.[[#TLS+12]]] = [B1.[[#TLS+1]]]
413439
// CHECK-NEXT: [[#TLS+4]]: cond
414440
// CHECK-NEXT: [[#TLS+5]]: [B1.[[#TLS+4]]] (ImplicitCastExpr, LValueToRValue, int)
415441
// CHECK-NEXT: [[#TLS+6]]: [B1.[[#TLS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
416442
// CHECK-NEXT: [[#TLS+7]]: fp
417443
// CHECK-NEXT: [[#TLS+8]]: rd
418-
// CHECK-NEXT: [[#TLS+9]]: argc
419-
// CHECK-NEXT: [[#TLS+10]]: x
420-
// CHECK-NEXT: [[#TLS+11]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd)
444+
// CHECK-NEXT: [[#TLS+9]]: lin
445+
// CHECK-NEXT: [[#TLS+10]]: step
446+
// CHECK-NEXT: [[#TLS+11]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
447+
// CHECK-NEXT: [[#TLS+12]]: argc
448+
// CHECK-NEXT: [[#TLS+13]]: x
449+
// CHECK-NEXT: [[#TLS+14]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
421450
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
422451
// CHECK-NEXT: [B1.[[#TLS+3]]];
423-
#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd)
452+
#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
424453
for (int i = 0; i < 10; ++i)
425454
argc = x;
426455
// CHECK-NEXT: [[#TDPF:]]: x

0 commit comments

Comments
 (0)