================
@@ -16528,6 +16535,309 @@ 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);
+ 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);
+ ExprResult NVal =
+ widenIterationCount(Bits, MakeNumIterations(I), SemaRef);
+ if (!NCmp.isUsable() || !NVal.isUsable())
+ return ExprError();
+ ExprResult N = ClampNonNegative(NCmp.get(), NVal.get());
+ if (!N.isUsable())
+ return ExprError();
+ if (I == 0)
+ Product = N;
+ else
+ Product = SemaRef.BuildBinOp(CurScope, CondLoc, BO_Mul, Product.get(),
+ N.get());
+ if (!Product.isUsable())
+ return ExprError();
+ }
+ return Product;
+ };
+
+ bool AllCountsLessThan32Bits =
+ llvm::all_of(llvm::seq<unsigned>(NumLoops), [&](unsigned I) {
+ return Context.getTypeSize(LoopHelpers[I].NumIterations->getType()) <
+ 32;
+ });
+
+ ExprResult TripCount;
+ if (AllCountsLessThan32Bits || NumLoops == 1) {
+ TripCount = BuildTripCount(/*Bits=*/32);
+ } else {
+ ExprResult TripCount64 = BuildTripCount(/*Bits=*/64);
+ if (!TripCount64.isUsable())
+ return StmtError();
+ if (fitsInto(
----------------
alexey-bataev wrote:
```suggestion
if (TripCount64.get()->isIntegerConstantExpr(Context)) {
ExprResult TripCount32 = BuildTripCount(/*Bits=*/32);
if (TripCount32.isUsable() &&
Context.getTypeSize(TripCount32.get()->getType()) == 32 &&
fitsInto(
/*Bits=*/32,
TripCount32.get()->getType()->hasSignedIntegerRepresentation(),
TripCount64.get(), SemaRef))```
https://github.com/llvm/llvm-project/pull/206977
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
