================
@@ -16528,6 +16535,308 @@ StmtResult
SemaOpenMP::ActOnOpenMPInterchangeDirective(
buildPreInits(Context, PreInits));
}
+StmtResult
+SemaOpenMP::ActOnOpenMPFlattenDirective(ArrayRef<OMPClause *> Clauses,
+ Stmt *AStmt, SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ ASTContext &Context = getASTContext();
+ DeclContext *CurContext = SemaRef.CurContext;
+ Scope *CurScope = SemaRef.getCurScope();
+
+ // Empty statement should only be possible if there already was an error.
+ if (!AStmt)
+ return StmtError();
+
+ // flatten without 'depth' clause combines two loops; 'depth(k)' selects k.
+ unsigned NumLoops = 2;
+ bool DepthIsDependent = false;
+ const auto *DepthClause =
+ OMPExecutableDirective::getSingleClause<OMPDepthClause>(Clauses);
+ if (DepthClause) {
+ Expr *DepthExpr = DepthClause->getDepth();
+ if (DepthExpr && DepthExpr->isInstantiationDependent()) {
+ DepthIsDependent = true;
+ } else if (DepthExpr) {
+ Expr::EvalResult EvalResult;
+ if (DepthExpr->EvaluateAsInt(EvalResult, Context))
+ NumLoops = EvalResult.Val.getInt().getLimitedValue(
+ std::numeric_limits<unsigned>::max());
+ }
+ }
+
+ // Count perfectly nested loops with doForAllLoops. When 'depth' is present,
+ // walk NumLoops iterations to diagnose an insufficient nest. When it is
+ // omitted, walk one extra loop (3 total) so we can warn that default
+ // flatten only combines 2 of a deeper nest.
+ if (!DepthIsDependent) {
+ unsigned WalkLimit = DepthClause ? NumLoops : 3;
+ unsigned Found = 0;
+ bool Enough = OMPLoopBasedDirective::doForAllLoops(
+ AStmt->IgnoreContainers(), /*TryImperfectlyNestedLoops=*/false,
+ WalkLimit, [&](unsigned Cnt, Stmt *S) {
+ if (!isa<ForStmt>(S) && !isa<CXXForRangeStmt>(S))
+ return true;
+ Found = Cnt + 1;
+ return false;
+ });
+ if (DepthClause && !Enough) {
+ Diag(AStmt->getBeginLoc(), diag::err_omp_not_for)
+ << /*expected N for loops form=*/1
+ << getOpenMPDirectiveName(OMPD_flatten) << NumLoops << (Found > 0)
+ << Found;
+ return StmtError();
+ }
+ if (!DepthClause && Found >= 3) {
+ Diag(StartLoc, diag::warn_omp_flatten_omitted_depth);
+ if (SemaRef.getLangOpts().OpenMP >= 61)
+ Diag(StartLoc, diag::note_omp_flatten_insert_depth)
+ << FixItHint::CreateInsertion(EndLoc, " depth(2)");
+ }
+ }
+
+ // Defer when 'depth' is instantiation-dependent (concrete k unknown until
+ // instantiation).
+ if (DepthIsDependent)
+ return OMPFlattenDirective::Create(Context, StartLoc, EndLoc, Clauses,
+ NumLoops, AStmt, nullptr, nullptr);
+
+ // Verify and diagnose loop nest.
+ SmallVector<OMPLoopBasedDirective::HelperExprs, 4> LoopHelpers(NumLoops);
+ Stmt *Body = nullptr;
+ SmallVector<SmallVector<Stmt *>, 4> OriginalInits;
+ if (!checkTransformableLoopNest(OMPD_flatten, AStmt, NumLoops, LoopHelpers,
+ Body, OriginalInits))
+ return StmtError();
+
+ // Delay flattening to when template is completely instantiated.
+ if (CurContext->isDependentContext())
+ return OMPFlattenDirective::Create(Context, StartLoc, EndLoc, Clauses,
+ NumLoops, AStmt, nullptr, nullptr);
+
+ assert(LoopHelpers.size() == NumLoops &&
+ "Expecting loop iteration space dimensionality to match number of "
+ "affected loops");
+ assert(OriginalInits.size() == NumLoops &&
+ "Expecting loop iteration space dimensionality to match number of "
+ "affected loops");
+
+ // Find the affected loops.
+ SmallVector<Stmt *> LoopStmts(NumLoops, nullptr);
+ collectLoopStmts(AStmt, LoopStmts);
+
+ // Collect pre-init statements in outer-to-inner order.
+ SmallVector<Stmt *> PreInits;
+ for (auto I : llvm::seq<int>(NumLoops)) {
+ OMPLoopBasedDirective::HelperExprs &LoopHelper = LoopHelpers[I];
+ assert(LoopHelper.Counters.size() == 1 &&
+ "Single-dimensional loop iteration space expected");
+ addLoopPreInits(Context, LoopHelper, LoopStmts[I], OriginalInits[I],
+ PreInits);
+ }
+
+ CaptureVars CopyTransformer(SemaRef);
+ auto MakeNumIterations = [&CopyTransformer,
+ &LoopHelpers](unsigned I) -> Expr * {
+ return AssertSuccess(
+ CopyTransformer.TransformExpr(LoopHelpers[I].NumIterations));
+ };
+
+ OMPLoopBasedDirective::HelperExprs &OutermostHelper = LoopHelpers[0];
+ auto *OutermostCntVar = cast<DeclRefExpr>(OutermostHelper.Counters.front());
+ SourceLocation OrigVarLoc = OutermostCntVar->getExprLoc();
+ SourceLocation OrigVarLocBegin = OutermostCntVar->getBeginLoc();
+ SourceLocation OrigVarLocEnd = OutermostCntVar->getEndLoc();
+ SourceLocation CondLoc = OutermostHelper.Cond->getExprLoc();
+
+ // Canonical empty loops have a negative computed trip count (e.g. i < -1
+ // yields -1). Clamp each count to max(0, N) before multiplying; otherwise
two
+ // empty loops give a positive product and the flattened body runs.
+ auto ClampNonNegative = [&](Expr *Cmp, Expr *Val) -> ExprResult {
+ QualType Ty = Val->getType();
+ ExprResult ZeroLT = SemaRef.PerformImplicitConversion(
+ SemaRef.ActOnIntegerConstant(CondLoc, 0).get(), Ty,
+ AssignmentAction::Converting, /*AllowExplicit=*/true);
+ ExprResult ZeroVal = SemaRef.PerformImplicitConversion(
+ SemaRef.ActOnIntegerConstant(CondLoc, 0).get(), Ty,
+ AssignmentAction::Converting, /*AllowExplicit=*/true);
+ if (!ZeroLT.isUsable() || !ZeroVal.isUsable())
+ return ExprError();
+ ExprResult IsNeg =
+ SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, Cmp, ZeroLT.get());
+ if (!IsNeg.isUsable())
+ return ExprError();
+ return SemaRef.ActOnConditionalOp(CondLoc, CondLoc, IsNeg.get(),
+ ZeroVal.get(), Val);
+ };
+
+ // Product of trip counts; mirror 'collapse' IV-width selection to avoid
+ // overflow when several counts are multiplied.
+ auto BuildTripCount = [&](unsigned Bits) -> ExprResult {
+ ExprResult Product;
+ for (unsigned I = 0; I < NumLoops; ++I) {
+ ExprResult NCmp =
+ widenIterationCount(Bits, MakeNumIterations(I), SemaRef);
----------------
loopacino wrote:
Because one `Expr` can't be both the condition operand and the branch of the
same ternary expression.
https://github.com/llvm/llvm-project/pull/206977
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
