std::copy(FL.begin(), FL.end(), getUpdates().end());
}
+void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) {
+ assert(
+ UE.size() == varlist_size() + 1 &&
+ "Number of used expressions is not the same as the preallocated buffer");
+ std::copy(UE.begin(), UE.end(), getFinals().end() + 2);
+}
+
OMPLinearClause *OMPLinearClause::Create(
const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
Stmt *PreInit, Expr *PostUpdate) {
- // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
- // (Step and CalcStep).
- void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2));
+ // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
+ // (Step and CalcStep), list of used expression + step.
+ void *Mem =
+ C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
OMPLinearClause *Clause = new (Mem) OMPLinearClause(
StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
Clause->setVarRefs(VL);
nullptr);
std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
nullptr);
+ std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(),
+ nullptr);
Clause->setStep(Step);
Clause->setCalcStep(CalcStep);
Clause->setPreInitStmt(PreInit);
OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
unsigned NumVars) {
- // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
- // (Step and CalcStep).
- void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2));
+ // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
+ // (Step and CalcStep), list of used expression + step.
+ void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars +1));
return new (Mem) OMPLinearClause(NumVars);
}
+OMPClause::child_range OMPLinearClause::used_children() {
+ // Range includes only non-nullptr elements.
+ return child_range(
+ reinterpret_cast<Stmt **>(getUsedExprs().begin()),
+ reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr)));
+}
+
OMPAlignedClause *
OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
SourceLocation LParenLoc, SourceLocation ColonLoc,
// CHECK-NEXT: 2: int cond;
// CHECK-NEXT: 3: int fp;
// CHECK-NEXT: 4: int rd;
- int x, cond, fp, rd;
+// CHECK-NEXT: 5: int lin;
+// CHECK-NEXT: 6: int step;
+ int x, cond, fp, rd, lin, step;
// CHECK-NEXT: [[#ATOM:]]: x
// CHECK-NEXT: [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#ATOM+2]]: argc
// CHECK-NEXT: [[#FOR+1]]: [B1.[[#FOR]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#FOR+2]]: argc
// CHECK-NEXT: [[#FOR+3]]: [B1.[[#FOR+2]]] = [B1.[[#FOR+1]]]
-// CHECK-NEXT: [[#FOR+4]]: #pragma omp for
+// CHECK-NEXT: [[#FOR+4]]: lin
+// CHECK-NEXT: [[#FOR+5]]: step
+// CHECK-NEXT: [[#FOR+6]]: [B1.[[#FOR+5]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#FOR+7]]: #pragma omp for linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#FOR+3]]];
-#pragma omp for
+#pragma omp for linear(lin : step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#FS:]]: x
// CHECK-NEXT: [[#FS+1]]: [B1.[[#FS]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#FS+2]]: argc
// CHECK-NEXT: [[#FS+3]]: [B1.[[#FS+2]]] = [B1.[[#FS+1]]]
-// CHECK-NEXT: [[#FS+4]]: #pragma omp for simd
+// CHECK-NEXT: [[#FS+4]]: lin
+// CHECK-NEXT: [[#FS+5]]: step
+// CHECK-NEXT: [[#FS+6]]: [B1.[[#FS+5]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#FS+7]]: #pragma omp for simd linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#FS+3]]];
-#pragma omp for simd
+#pragma omp for simd linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#MASTER:]]: x
// CHECK-NEXT: [[#PF+6]]: [B1.[[#PF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#PF+7]]: fp
// CHECK-NEXT: [[#PF+8]]: rd
-// CHECK-NEXT: [[#PF+9]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd)
+// CHECK-NEXT: [[#PF+9]]: lin
+// CHECK-NEXT: [[#PF+10]]: step
+// CHECK-NEXT: [[#PF+11]]: [B1.[[#PF+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#PF+12]]: #pragma omp parallel for if(cond) firstprivate(fp) reduction(&: rd) linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#PF+3]]];
-#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd)
+#pragma omp parallel for if(cond) firstprivate(fp) reduction(&:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#PFS:]]: x
// CHECK-NEXT: [[#PFS+6]]: [B1.[[#PFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#PFS+7]]: fp
// CHECK-NEXT: [[#PFS+8]]: rd
-// CHECK-NEXT: [[#PFS+9]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd)
+// CHECK-NEXT: [[#PFS+9]]: lin
+// CHECK-NEXT: [[#PFS+10]]: step
+// CHECK-NEXT: [[#PFS+11]]: [B1.[[#PFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#PFS+12]]: #pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|: rd) linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#PFS+3]]];
-#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd)
+#pragma omp parallel for simd if(cond) firstprivate(fp) reduction(|:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#PAR:]]: x
// CHECK-NEXT: [[#SIMD+1]]: [B1.[[#SIMD]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#SIMD+2]]: argc
// CHECK-NEXT: [[#SIMD+3]]: [B1.[[#SIMD+2]]] = [B1.[[#SIMD+1]]]
-// CHECK-NEXT: [[#SIMD+4]]: #pragma omp simd
+// CHECK-NEXT: [[#SIMD+4]]: lin
+// CHECK-NEXT: [[#SIMD+5]]: step
+// CHECK-NEXT: [[#SIMD+6]]: [B1.[[#SIMD+5]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#SIMD+7]]: #pragma omp simd linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#SIMD+3]]];
-#pragma omp simd
+#pragma omp simd linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#SINGLE:]]: x
: argc) if(cond) firstprivate(fp) reduction(-:rd)
argc = x;
// CHECK-NEXT: [[#TPF:]]:
-// CHECK-SAME: [B1.[[#TPF+10]]]
-// CHECK-NEXT: [[#TPF+1]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT: [[#TPF+2]]: [B1.[[#TPF+9]]]
-// CHECK-NEXT: [[#TPF+3]]: [B1.[[#TPF+9]]] = [B1.[[#TPF+1]]]
+// CHECK-SAME: [B1.[[#TPF+13]]]
+// CHECK-NEXT: [[#TPF+1]]: [B1.[[#TPF+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TPF+2]]: [B1.[[#TPF+12]]]
+// CHECK-NEXT: [[#TPF+3]]: [B1.[[#TPF+12]]] = [B1.[[#TPF+1]]]
// CHECK-NEXT: [[#TPF+4]]: cond
// CHECK-NEXT: [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TPF+7]]: fp
// CHECK-NEXT: [[#TPF+8]]: rd
-// CHECK-NEXT: [[#TPF+9]]: argc
-// CHECK-NEXT: [[#TPF+10]]: x
-// CHECK-NEXT: [[#TPF+11]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd)
+// CHECK-NEXT: [[#TPF+9]]: lin
+// CHECK-NEXT: [[#TPF+10]]: step
+// CHECK-NEXT: [[#TPF+11]]: [B1.[[#TPF+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TPF+12]]: argc
+// CHECK-NEXT: [[#TPF+13]]: x
+// CHECK-NEXT: [[#TPF+14]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp) reduction(max: rd) linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TPF+3]]];
-#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd)
+#pragma omp target parallel for if(parallel:cond) firstprivate(fp) reduction(max:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#TPFS:]]:
-// CHECK-SAME: [B1.[[#TPFS+10]]]
-// CHECK-NEXT: [[#TPFS+1]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT: [[#TPFS+2]]: [B1.[[#TPFS+9]]]
-// CHECK-NEXT: [[#TPFS+3]]: [B1.[[#TPFS+9]]] = [B1.[[#TPFS+1]]]
+// CHECK-SAME: [B1.[[#TPFS+13]]]
+// CHECK-NEXT: [[#TPFS+1]]: [B1.[[#TPFS+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TPFS+2]]: [B1.[[#TPFS+12]]]
+// CHECK-NEXT: [[#TPFS+3]]: [B1.[[#TPFS+12]]] = [B1.[[#TPFS+1]]]
// CHECK-NEXT: [[#TPFS+4]]: cond
// CHECK-NEXT: [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TPFS+7]]: fp
// CHECK-NEXT: [[#TPFS+8]]: rd
-// CHECK-NEXT: [[#TPFS+9]]: argc
-// CHECK-NEXT: [[#TPFS+10]]: x
-// CHECK-NEXT: [[#TPFS+11]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd)
+// CHECK-NEXT: [[#TPFS+9]]: lin
+// CHECK-NEXT: [[#TPFS+10]]: step
+// CHECK-NEXT: [[#TPFS+11]]: [B1.[[#TPFS+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TPFS+12]]: argc
+// CHECK-NEXT: [[#TPFS+13]]: x
+// CHECK-NEXT: [[#TPFS+14]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp) reduction(*: rd) linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TPFS+3]]];
-#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd)
+#pragma omp target parallel for simd if(target:cond) firstprivate(fp) reduction(*:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#TP:]]:
#pragma omp target parallel if(cond) firstprivate(fp) reduction(+:rd)
argc = x;
// CHECK-NEXT: [[#TSIMD:]]:
-// CHECK-SAME: [B1.[[#TSIMD+10]]]
-// CHECK-NEXT: [[#TSIMD+1]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT: [[#TSIMD+2]]: [B1.[[#TSIMD+9]]]
-// CHECK-NEXT: [[#TSIMD+3]]: [B1.[[#TSIMD+9]]] = [B1.[[#TSIMD+1]]]
+// CHECK-SAME: [B1.[[#TSIMD+13]]]
+// CHECK-NEXT: [[#TSIMD+1]]: [B1.[[#TSIMD+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TSIMD+2]]: [B1.[[#TSIMD+12]]]
+// CHECK-NEXT: [[#TSIMD+3]]: [B1.[[#TSIMD+12]]] = [B1.[[#TSIMD+1]]]
// CHECK-NEXT: [[#TSIMD+4]]: cond
// CHECK-NEXT: [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TSIMD+7]]: fp
// CHECK-NEXT: [[#TSIMD+8]]: rd
-// CHECK-NEXT: [[#TSIMD+9]]: argc
-// CHECK-NEXT: [[#TSIMD+10]]: x
-// CHECK-NEXT: [[#TSIMD+11]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd)
+// CHECK-NEXT: [[#TSIMD+9]]: lin
+// CHECK-NEXT: [[#TSIMD+10]]: step
+// CHECK-NEXT: [[#TSIMD+11]]: [B1.[[#TSIMD+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TSIMD+12]]: argc
+// CHECK-NEXT: [[#TSIMD+13]]: x
+// CHECK-NEXT: [[#TSIMD+14]]: #pragma omp target simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TSIMD+3]]];
-#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd)
+#pragma omp target simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#TTD:]]:
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#TLS:]]:
-// CHECK-SAME: [B1.[[#TLS+10]]]
-// CHECK-NEXT: [[#TLS+1]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT: [[#TLS+2]]: [B1.[[#TLS+9]]]
-// CHECK-NEXT: [[#TLS+3]]: [B1.[[#TLS+9]]] = [B1.[[#TLS+1]]]
+// CHECK-SAME: [B1.[[#TLS+13]]]
+// CHECK-NEXT: [[#TLS+1]]: [B1.[[#TLS+13]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TLS+2]]: [B1.[[#TLS+12]]]
+// CHECK-NEXT: [[#TLS+3]]: [B1.[[#TLS+12]]] = [B1.[[#TLS+1]]]
// CHECK-NEXT: [[#TLS+4]]: cond
// CHECK-NEXT: [[#TLS+5]]: [B1.[[#TLS+4]]] (ImplicitCastExpr, LValueToRValue, int)
// CHECK-NEXT: [[#TLS+6]]: [B1.[[#TLS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
// CHECK-NEXT: [[#TLS+7]]: fp
// CHECK-NEXT: [[#TLS+8]]: rd
-// CHECK-NEXT: [[#TLS+9]]: argc
-// CHECK-NEXT: [[#TLS+10]]: x
-// CHECK-NEXT: [[#TLS+11]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd)
+// CHECK-NEXT: [[#TLS+9]]: lin
+// CHECK-NEXT: [[#TLS+10]]: step
+// CHECK-NEXT: [[#TLS+11]]: [B1.[[#TLS+10]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: [[#TLS+12]]: argc
+// CHECK-NEXT: [[#TLS+13]]: x
+// CHECK-NEXT: [[#TLS+14]]: #pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: [B1.[[#TLS+3]]];
-#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd)
+#pragma omp taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
for (int i = 0; i < 10; ++i)
argc = x;
// CHECK-NEXT: [[#TDPF:]]: x