diff --git a/clang/include/clang-c/Index.h b/clang/include/clang-c/Index.h --- a/clang/include/clang-c/Index.h +++ b/clang/include/clang-c/Index.h @@ -2600,7 +2600,11 @@ */ CXCursor_OMPGenericLoopDirective = 295, - CXCursor_LastStmt = CXCursor_OMPGenericLoopDirective, + /** OpenMP teams loop directive. + */ + CXCursor_OMPTeamsGenericLoopDirective = 296, + + CXCursor_LastStmt = CXCursor_OMPTeamsGenericLoopDirective, /** * Cursor that represents the translation unit itself. diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -3074,6 +3074,9 @@ DEF_TRAVERSE_STMT(OMPGenericLoopDirective, { TRY_TO(TraverseOMPExecutableDirective(S)); }) +DEF_TRAVERSE_STMT(OMPTeamsGenericLoopDirective, + { TRY_TO(TraverseOMPExecutableDirective(S)); }) + // OpenMP clauses. template bool RecursiveASTVisitor::TraverseOMPClause(OMPClause *C) { diff --git a/clang/include/clang/AST/StmtOpenMP.h b/clang/include/clang/AST/StmtOpenMP.h --- a/clang/include/clang/AST/StmtOpenMP.h +++ b/clang/include/clang/AST/StmtOpenMP.h @@ -1526,6 +1526,7 @@ T->getStmtClass() == OMPMasterTaskLoopDirectiveClass || T->getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass || T->getStmtClass() == OMPGenericLoopDirectiveClass || + T->getStmtClass() == OMPTeamsGenericLoopDirectiveClass || T->getStmtClass() == OMPParallelMasterTaskLoopDirectiveClass || T->getStmtClass() == OMPParallelMasterTaskLoopSimdDirectiveClass || T->getStmtClass() == OMPDistributeDirectiveClass || @@ -5569,6 +5570,71 @@ } }; +/// This represents '#pragma omp teams loop' directive. +/// +/// \code +/// #pragma omp teams loop private(a,b) order(concurrent) +/// \endcode +/// In this example directive '#pragma omp teams loop' has +/// clauses 'private' with the variables 'a' and 'b', and order(concurrent). +/// +class OMPTeamsGenericLoopDirective final : public OMPLoopDirective { + friend class ASTStmtReader; + friend class OMPExecutableDirective; + /// Build directive with the given start and end location. + /// + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending location of the directive. + /// \param CollapsedNum Number of collapsed nested loops. + /// + OMPTeamsGenericLoopDirective(SourceLocation StartLoc, SourceLocation EndLoc, + unsigned CollapsedNum) + : OMPLoopDirective(OMPTeamsGenericLoopDirectiveClass, + llvm::omp::OMPD_teams_loop, StartLoc, EndLoc, + CollapsedNum) {} + + /// Build an empty directive. + /// + /// \param CollapsedNum Number of collapsed nested loops. + /// + explicit OMPTeamsGenericLoopDirective(unsigned CollapsedNum) + : OMPLoopDirective(OMPTeamsGenericLoopDirectiveClass, + llvm::omp::OMPD_teams_loop, SourceLocation(), + SourceLocation(), CollapsedNum) {} + +public: + /// Creates directive with a list of \p Clauses. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// \param CollapsedNum Number of collapsed loops. + /// \param Clauses List of clauses. + /// \param AssociatedStmt Statement, associated with the directive. + /// \param Exprs Helper expressions for CodeGen. + /// + static OMPTeamsGenericLoopDirective * + Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + unsigned CollapsedNum, ArrayRef Clauses, + Stmt *AssociatedStmt, const HelperExprs &Exprs); + + /// Creates an empty directive with the place + /// for \a NumClauses clauses. + /// + /// \param C AST context. + /// \param CollapsedNum Number of collapsed nested loops. + /// \param NumClauses Number of clauses. + /// + static OMPTeamsGenericLoopDirective *CreateEmpty(const ASTContext &C, + unsigned NumClauses, + unsigned CollapsedNum, + EmptyShell); + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPTeamsGenericLoopDirectiveClass; + } +}; + } // end namespace clang #endif diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -10898,7 +10898,7 @@ : Note<"jump exits scope of OpenMP structured block">; def err_omp_lastprivate_loop_var_non_loop_iteration : Error< "only loop iteration variables are allowed in 'lastprivate' clause in " - "'omp loop' directives">; + "'omp %0' directives">; def err_omp_interop_variable_expected : Error< "expected%select{| non-const}0 variable of type 'omp_interop_t'">; def err_omp_interop_variable_wrong_type : Error< diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td --- a/clang/include/clang/Basic/StmtNodes.td +++ b/clang/include/clang/Basic/StmtNodes.td @@ -283,3 +283,4 @@ def OMPDispatchDirective : StmtNode; def OMPMaskedDirective : StmtNode; def OMPGenericLoopDirective : StmtNode; +def OMPTeamsGenericLoopDirective : StmtNode; diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -10904,6 +10904,11 @@ StmtResult ActOnOpenMPTeamsDirective(ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc); + /// Called on well-formed '\#pragma omp teams loop' after parsing of the + /// associated statement. + StmtResult ActOnOpenMPTeamsGenericLoopDirective( + ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA); /// Called on well-formed '\#pragma omp cancellation point'. StmtResult ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc, diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -1961,6 +1961,7 @@ STMT_OMP_DISPATCH_DIRECTIVE, STMT_OMP_MASKED_DIRECTIVE, STMT_OMP_GENERIC_LOOP_DIRECTIVE, + STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE, EXPR_OMP_ARRAY_SECTION, EXPR_OMP_ARRAY_SHAPING, EXPR_OMP_ITERATOR, diff --git a/clang/lib/AST/StmtOpenMP.cpp b/clang/lib/AST/StmtOpenMP.cpp --- a/clang/lib/AST/StmtOpenMP.cpp +++ b/clang/lib/AST/StmtOpenMP.cpp @@ -2136,3 +2136,47 @@ C, NumClauses, /*HasAssociatedStmt=*/true, numLoopChildren(CollapsedNum, OMPD_loop), CollapsedNum); } + +OMPTeamsGenericLoopDirective *OMPTeamsGenericLoopDirective::Create( + const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, + unsigned CollapsedNum, ArrayRef Clauses, Stmt *AssociatedStmt, + const HelperExprs &Exprs) { + auto *Dir = createDirective( + C, Clauses, AssociatedStmt, + numLoopChildren(CollapsedNum, OMPD_teams_loop), StartLoc, EndLoc, + CollapsedNum); + Dir->setIterationVariable(Exprs.IterationVarRef); + Dir->setLastIteration(Exprs.LastIteration); + Dir->setCalcLastIteration(Exprs.CalcLastIteration); + Dir->setPreCond(Exprs.PreCond); + Dir->setCond(Exprs.Cond); + Dir->setInit(Exprs.Init); + Dir->setInc(Exprs.Inc); + Dir->setIsLastIterVariable(Exprs.IL); + Dir->setLowerBoundVariable(Exprs.LB); + Dir->setUpperBoundVariable(Exprs.UB); + Dir->setStrideVariable(Exprs.ST); + Dir->setEnsureUpperBound(Exprs.EUB); + Dir->setNextLowerBound(Exprs.NLB); + Dir->setNextUpperBound(Exprs.NUB); + Dir->setNumIterations(Exprs.NumIterations); + Dir->setCounters(Exprs.Counters); + Dir->setPrivateCounters(Exprs.PrivateCounters); + Dir->setInits(Exprs.Inits); + Dir->setUpdates(Exprs.Updates); + Dir->setFinals(Exprs.Finals); + Dir->setDependentCounters(Exprs.DependentCounters); + Dir->setDependentInits(Exprs.DependentInits); + Dir->setFinalsConditions(Exprs.FinalsConditions); + Dir->setPreInits(Exprs.PreInits); + return Dir; +} + +OMPTeamsGenericLoopDirective * +OMPTeamsGenericLoopDirective::CreateEmpty(const ASTContext &C, + unsigned NumClauses, + unsigned CollapsedNum, EmptyShell) { + return createEmptyDirective( + C, NumClauses, /*HasAssociatedStmt=*/true, + numLoopChildren(CollapsedNum, OMPD_teams_loop), CollapsedNum); +} diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp --- a/clang/lib/AST/StmtPrinter.cpp +++ b/clang/lib/AST/StmtPrinter.cpp @@ -1005,6 +1005,12 @@ PrintOMPExecutableDirective(Node); } +void StmtPrinter::VisitOMPTeamsGenericLoopDirective( + OMPTeamsGenericLoopDirective *Node) { + Indent() << "#pragma omp teams loop"; + PrintOMPExecutableDirective(Node); +} + //===----------------------------------------------------------------------===// // Expr printing methods. //===----------------------------------------------------------------------===// diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -1207,6 +1207,11 @@ VisitOMPLoopDirective(S); } +void StmtProfiler::VisitOMPTeamsGenericLoopDirective( + const OMPTeamsGenericLoopDirective *S) { + VisitOMPLoopDirective(S); +} + void StmtProfiler::VisitExpr(const Expr *S) { VisitStmt(S); } diff --git a/clang/lib/Basic/OpenMPKinds.cpp b/clang/lib/Basic/OpenMPKinds.cpp --- a/clang/lib/Basic/OpenMPKinds.cpp +++ b/clang/lib/Basic/OpenMPKinds.cpp @@ -495,7 +495,7 @@ DKind == OMPD_target_teams_distribute_parallel_for || DKind == OMPD_target_teams_distribute_parallel_for_simd || DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile || - DKind == OMPD_unroll || DKind == OMPD_loop; + DKind == OMPD_unroll || DKind == OMPD_loop || DKind == OMPD_teams_loop; } bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { @@ -555,7 +555,8 @@ return DKind == OMPD_teams || DKind == OMPD_teams_distribute || DKind == OMPD_teams_distribute_simd || DKind == OMPD_teams_distribute_parallel_for_simd || - DKind == OMPD_teams_distribute_parallel_for; + DKind == OMPD_teams_distribute_parallel_for || + DKind == OMPD_teams_loop; } bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { @@ -599,7 +600,7 @@ } bool clang::isOpenMPGenericLoopDirective(OpenMPDirectiveKind Kind) { - return Kind == OMPD_loop; + return Kind == OMPD_loop || Kind == OMPD_teams_loop; } bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { @@ -700,6 +701,9 @@ CaptureRegions.push_back(OMPD_teams); CaptureRegions.push_back(OMPD_parallel); break; + case OMPD_teams_loop: + CaptureRegions.push_back(OMPD_teams); + break; case OMPD_loop: // TODO: 'loop' may require different capture regions depending on the bind // clause or the parent directive when there is no bind clause. Use diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp --- a/clang/lib/CodeGen/CGStmt.cpp +++ b/clang/lib/CodeGen/CGStmt.cpp @@ -396,6 +396,9 @@ case Stmt::OMPGenericLoopDirectiveClass: EmitOMPGenericLoopDirective(cast(*S)); break; + case Stmt::OMPTeamsGenericLoopDirectiveClass: + llvm_unreachable("teams loop directive not supported yet."); + break; } } diff --git a/clang/lib/Parse/ParseOpenMP.cpp b/clang/lib/Parse/ParseOpenMP.cpp --- a/clang/lib/Parse/ParseOpenMP.cpp +++ b/clang/lib/Parse/ParseOpenMP.cpp @@ -163,6 +163,7 @@ OMPD_teams_distribute_parallel_for}, {OMPD_teams_distribute_parallel_for, OMPD_simd, OMPD_teams_distribute_parallel_for_simd}, + {OMPD_teams, OMPD_loop, OMPD_teams_loop}, {OMPD_target, OMPD_teams, OMPD_target_teams}, {OMPD_target_teams, OMPD_distribute, OMPD_target_teams_distribute}, {OMPD_target_teams_distribute, OMPD_parallel, @@ -2399,6 +2400,7 @@ case OMPD_masked: case OMPD_metadirective: case OMPD_loop: + case OMPD_teams_loop: Diag(Tok, diag::err_omp_unexpected_directive) << 1 << getOpenMPDirectiveName(DKind); break; @@ -2754,6 +2756,7 @@ case OMPD_target_parallel: case OMPD_target_parallel_for: case OMPD_loop: + case OMPD_teams_loop: case OMPD_taskloop: case OMPD_taskloop_simd: case OMPD_master_taskloop: diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp --- a/clang/lib/Sema/SemaExceptionSpec.cpp +++ b/clang/lib/Sema/SemaExceptionSpec.cpp @@ -1499,6 +1499,7 @@ case Stmt::OMPMaskedDirectiveClass: case Stmt::OMPMetaDirectiveClass: case Stmt::OMPGenericLoopDirectiveClass: + case Stmt::OMPTeamsGenericLoopDirectiveClass: case Stmt::ReturnStmtClass: case Stmt::SEHExceptStmtClass: case Stmt::SEHFinallyStmtClass: diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -4262,6 +4262,22 @@ break; } + case OMPD_teams_loop: { + QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst(); + QualType KmpInt32PtrTy = + Context.getPointerType(KmpInt32Ty).withConst().withRestrict(); + + Sema::CapturedParamNameType ParamsTeams[] = { + std::make_pair(".global_tid.", KmpInt32PtrTy), + std::make_pair(".bound_tid.", KmpInt32PtrTy), + std::make_pair(StringRef(), QualType()) // __context with shared vars + }; + // Start a captured region for 'teams'. + ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, + ParamsTeams, /*OpenMPCaptureLevel=*/0); + break; + } + case OMPD_teams_distribute_parallel_for: case OMPD_teams_distribute_parallel_for_simd: { QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst(); @@ -6296,6 +6312,10 @@ Res = ActOnOpenMPGenericLoopDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); break; + case OMPD_teams_loop: + Res = ActOnOpenMPTeamsGenericLoopDirective( + ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); + break; case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_threadprivate: @@ -10129,32 +10149,42 @@ TargetCallLoc); } -StmtResult Sema::ActOnOpenMPGenericLoopDirective( - ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, - SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA) { - if (!AStmt) - return StmtError(); - - // OpenMP 5.1 [2.11.7, loop construct] - // A list item may not appear in a lastprivate clause unless it is the - // loop iteration variable of a loop that is associated with the construct. +static bool checkGenericLoopLastprivate(Sema &S, ArrayRef Clauses, + OpenMPDirectiveKind K, + DSAStackTy *Stack) { + bool ErrorFound = false; for (OMPClause *C : Clauses) { if (auto *LPC = dyn_cast(C)) { for (Expr *RefExpr : LPC->varlists()) { SourceLocation ELoc; SourceRange ERange; Expr *SimpleRefExpr = RefExpr; - auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); + auto Res = getPrivateItem(S, SimpleRefExpr, ELoc, ERange); if (ValueDecl *D = Res.first) { - auto &&Info = DSAStack->isLoopControlVariable(D); + auto &&Info = Stack->isLoopControlVariable(D); if (!Info.first) { - Diag(ELoc, diag::err_omp_lastprivate_loop_var_non_loop_iteration); - return StmtError(); + S.Diag(ELoc, diag::err_omp_lastprivate_loop_var_non_loop_iteration) + << getOpenMPDirectiveName(K); + ErrorFound = true; } } } } } + return ErrorFound; +} + +StmtResult Sema::ActOnOpenMPGenericLoopDirective( + ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA) { + if (!AStmt) + return StmtError(); + + // OpenMP 5.1 [2.11.7, loop construct, Restrictions] + // A list item may not appear in a lastprivate clause unless it is the + // loop iteration variable of a loop that is associated with the construct. + if (checkGenericLoopLastprivate(*this, Clauses, OMPD_loop, DSAStack)) + return StmtError(); auto *CS = cast(AStmt); // 1.2.2 OpenMP Language Terminology @@ -10180,6 +10210,55 @@ NestedLoopCount, Clauses, AStmt, B); } +StmtResult Sema::ActOnOpenMPTeamsGenericLoopDirective( + ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA) { + if (!AStmt) + return StmtError(); + + // OpenMP 5.1 [2.11.7, loop construct, Restrictions] + // A list item may not appear in a lastprivate clause unless it is the + // loop iteration variable of a loop that is associated with the construct. + if (checkGenericLoopLastprivate(*this, Clauses, OMPD_teams_loop, DSAStack)) + return StmtError(); + + auto *CS = cast(AStmt); + // 1.2.2 OpenMP Language Terminology + // Structured block - An executable statement with a single entry at the + // top and a single exit at the bottom. + // The point of exit cannot be a branch out of the structured block. + // longjmp() and throw() must not violate the entry/exit criteria. + CS->getCapturedDecl()->setNothrow(); + for (int ThisCaptureLevel = getOpenMPCaptureLevels(OMPD_teams_loop); + ThisCaptureLevel > 1; --ThisCaptureLevel) { + CS = cast(CS->getCapturedStmt()); + // 1.2.2 OpenMP Language Terminology + // Structured block - An executable statement with a single entry at the + // top and a single exit at the bottom. + // The point of exit cannot be a branch out of the structured block. + // longjmp() and throw() must not violate the entry/exit criteria. + CS->getCapturedDecl()->setNothrow(); + } + + OMPLoopDirective::HelperExprs B; + // In presence of clause 'collapse', it will define the nested loops number. + unsigned NestedLoopCount = + checkOpenMPLoop(OMPD_teams_loop, getCollapseNumberExpr(Clauses), + /*OrderedLoopCountExpr=*/nullptr, CS, *this, *DSAStack, + VarsWithImplicitDSA, B); + if (NestedLoopCount == 0) + return StmtError(); + + assert((CurContext->isDependentContext() || B.builtAll()) && + "omp loop exprs were not built"); + + setFunctionHasBranchProtectedScope(); + DSAStack->setParentTeamsRegionLoc(StartLoc); + + return OMPTeamsGenericLoopDirective::Create( + Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); +} + StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, @@ -14518,6 +14597,7 @@ case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_loop: + case OMPD_teams_loop: case OMPD_teams: case OMPD_tile: case OMPD_unroll: @@ -14598,6 +14678,7 @@ case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_loop: + case OMPD_teams_loop: case OMPD_teams: case OMPD_simd: case OMPD_tile: @@ -14639,6 +14720,7 @@ case OMPD_teams: case OMPD_teams_distribute: case OMPD_teams_distribute_simd: + case OMPD_teams_loop: // Do not capture num_teams-clause expressions. break; case OMPD_distribute_parallel_for: @@ -14721,6 +14803,7 @@ case OMPD_teams: case OMPD_teams_distribute: case OMPD_teams_distribute_simd: + case OMPD_teams_loop: // Do not capture thread_limit-clause expressions. break; case OMPD_distribute_parallel_for: @@ -14848,6 +14931,7 @@ case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_loop: + case OMPD_teams_loop: case OMPD_simd: case OMPD_tile: case OMPD_unroll: @@ -14930,6 +15014,7 @@ case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_loop: + case OMPD_teams_loop: case OMPD_simd: case OMPD_tile: case OMPD_unroll: @@ -15013,6 +15098,7 @@ case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_loop: + case OMPD_teams_loop: case OMPD_simd: case OMPD_tile: case OMPD_unroll: @@ -15097,6 +15183,7 @@ case OMPD_declare_target: case OMPD_end_declare_target: case OMPD_loop: + case OMPD_teams_loop: case OMPD_simd: case OMPD_tile: case OMPD_unroll: diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -9249,6 +9249,17 @@ return Res; } +template +StmtResult TreeTransform::TransformOMPTeamsGenericLoopDirective( + OMPTeamsGenericLoopDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_teams_loop, DirName, nullptr, + D->getBeginLoc()); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + //===----------------------------------------------------------------------===// // OpenMP clause transformation //===----------------------------------------------------------------------===// diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp --- a/clang/lib/Serialization/ASTReaderStmt.cpp +++ b/clang/lib/Serialization/ASTReaderStmt.cpp @@ -2638,6 +2638,11 @@ VisitOMPLoopDirective(D); } +void ASTStmtReader::VisitOMPTeamsGenericLoopDirective( + OMPTeamsGenericLoopDirective *D) { + VisitOMPLoopDirective(D); +} + //===----------------------------------------------------------------------===// // ASTReader Implementation //===----------------------------------------------------------------------===// @@ -3593,6 +3598,14 @@ break; } + case STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE: { + unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields]; + unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1]; + S = OMPTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses, + CollapsedNum, Empty); + break; + } + case EXPR_CXX_OPERATOR_CALL: S = CXXOperatorCallExpr::CreateEmpty( Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp --- a/clang/lib/Serialization/ASTWriterStmt.cpp +++ b/clang/lib/Serialization/ASTWriterStmt.cpp @@ -2595,6 +2595,12 @@ Code = serialization::STMT_OMP_GENERIC_LOOP_DIRECTIVE; } +void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective( + OMPTeamsGenericLoopDirective *D) { + VisitOMPLoopDirective(D); + Code = serialization::STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE; +} + //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp --- a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -1297,6 +1297,7 @@ case Stmt::OMPDispatchDirectiveClass: case Stmt::OMPMaskedDirectiveClass: case Stmt::OMPGenericLoopDirectiveClass: + case Stmt::OMPTeamsGenericLoopDirectiveClass: case Stmt::CapturedStmtClass: case Stmt::OMPUnrollDirectiveClass: case Stmt::OMPMetaDirectiveClass: { diff --git a/clang/test/Analysis/cfg-openmp.cpp b/clang/test/Analysis/cfg-openmp.cpp --- a/clang/test/Analysis/cfg-openmp.cpp +++ b/clang/test/Analysis/cfg-openmp.cpp @@ -676,3 +676,28 @@ for (int i = 0; i < 10; ++i) argc = x; } + +// CHECK-LABEL: void teamsloop(int argc) +void teamsloop(int argc) { + int x, cond, fp, rd, lin, step, map; +// CHECK-DAG: [B1] +// CHECK-DAG: [[#TDS:]]: #pragma omp teams loop 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]]] +#pragma omp target +#pragma omp teams loop firstprivate(fp) reduction(+:rd) + for (int i = 0; i < 10; ++i) + argc = x; +} diff --git a/clang/test/OpenMP/teams_generic_loop_ast_print.cpp b/clang/test/OpenMP/teams_generic_loop_ast_print.cpp new file mode 100644 --- /dev/null +++ b/clang/test/OpenMP/teams_generic_loop_ast_print.cpp @@ -0,0 +1,103 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \ +// RUN: -fsyntax-only -verify %s + +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \ +// RUN: -ast-print %s | FileCheck %s + +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \ +// RUN: -emit-pch -o %t %s + +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \ +// RUN: -include-pch %t -ast-print %s | FileCheck %s + +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +//CHECK: template void templ_foo(T t) { +//CHECK: T j, z; +//CHECK: #pragma omp teams loop collapse(C) reduction(+: z) lastprivate(j) bind(thread) num_teams(C + 2) +//CHECK: for (T i = 0; i < t; ++i) +//CHECK: for (j = 0; j < t; ++j) +//CHECK: z += i + j; +//CHECK: } + +//CHECK: template<> void templ_foo(int t) { +//CHECK: int j, z; +//CHECK: #pragma omp teams loop collapse(2) reduction(+: z) lastprivate(j) bind(thread) num_teams(2 + 2) +//CHECK: for (int i = 0; i < t; ++i) +//CHECK: for (j = 0; j < t; ++j) +//CHECK: z += i + j; +//CHECK: } +template +void templ_foo(T t) { + + T j,z; + #pragma omp teams loop collapse(C) reduction(+:z) lastprivate(j) bind(thread) num_teams(C+2) + for (T i = 0; i(8); +} + +#endif // HEADER diff --git a/clang/test/OpenMP/teams_generic_loop_messages.cpp b/clang/test/OpenMP/teams_generic_loop_messages.cpp new file mode 100644 --- /dev/null +++ b/clang/test/OpenMP/teams_generic_loop_messages.cpp @@ -0,0 +1,145 @@ +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -verify -fopenmp \ +// RUN: -fopenmp-version=51 -Wuninitialized %s + +void foo() +{ + int i,j,k; + int z; + + // expected-error@+2 {{statement after '#pragma omp teams loop' must be a for loop}} + #pragma omp teams loop bind(thread) + i = 0; + + // OpenMP 5.1 [2.22 Nesting of regions] + // + // A barrier region may not be closely nested inside a worksharing, loop, + // task, taskloop, critical, ordered, atomic, or masked region. + + // expected-error@+3 {{region cannot be closely nested inside 'teams loop' region}} + #pragma omp teams loop bind(thread) + for (i=0; i<1000; ++i) { + #pragma omp barrier + } + + // A masked region may not be closely nested inside a worksharing, loop, + // atomic, task, or taskloop region. + + // expected-error@+3 {{region cannot be closely nested inside 'teams loop' region}} + #pragma omp teams loop bind(thread) + for (i=0; i<1000; ++i) { + #pragma omp masked filter(2) + { } + } + + // An ordered region that corresponds to an ordered construct without any + // clause or with the threads or depend clause may not be closely nested + // inside a critical, ordered, loop, atomic, task, or taskloop region. + + // expected-error@+3 {{region cannot be closely nested inside 'teams loop' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + #pragma omp teams loop bind(thread) + for (i=0; i<1000; ++i) { + #pragma omp ordered + { } + } + + // expected-error@+3 {{region cannot be closely nested inside 'teams loop' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + #pragma omp teams loop bind(thread) + for (i=0; i<1000; ++i) { + #pragma omp ordered threads + { } + } + + // expected-error@+3 {{region cannot be closely nested inside 'teams loop' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}} + #pragma omp teams loop bind(thread) + for (i=0; i<1000; ++i) { + #pragma omp ordered depend(source) + } + + // bind clause + + // expected-error@+1 {{directive '#pragma omp teams loop' cannot contain more than one 'bind' clause}} + #pragma omp teams loop bind(thread) bind(thread) + for (i=0; i<1000; ++i) { + } + + // expected-error@+2 {{expected 'teams', 'parallel' or 'thread' in OpenMP clause 'bind'}} + #pragma omp target + #pragma omp teams loop bind(other) + for (i=0; i<1000; ++i) { + } + + // collapse clause + + // expected-error@+4 {{expected 2 for loops after '#pragma omp teams loop', but found only 1}} + // expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp teams loop collapse(2) bind(thread) + for (i=0; i<1000; ++i) + z = i+11; + + // expected-error@+1 {{directive '#pragma omp teams loop' cannot contain more than one 'collapse' clause}} + #pragma omp teams loop collapse(2) collapse(2) bind(thread) + for (i=0; i<1000; ++i) + for (j=0; j<1000; ++j) + z = i+j+11; + + // order clause + + // expected-error@+1 {{expected 'concurrent' in OpenMP clause 'order'}} + #pragma omp teams loop order(foo) bind(thread) + for (i=0; i<1000; ++i) + z = i+11; + + // private clause + + // expected-error@+1 {{use of undeclared identifier 'undef_var'}} + #pragma omp teams loop private(undef_var) bind(thread) + for (i=0; i<1000; ++i) + z = i+11; + + // lastprivate + + // A list item may not appear in a lastprivate clause unless it is the loop + // iteration variable of a loop that is associated with the construct. + + // expected-error@+1 {{only loop iteration variables are allowed in 'lastprivate' clause in 'omp teams loop' directives}} + #pragma omp teams loop lastprivate(z) bind(thread) + for (i=0; i<1000; ++i) { + z = i+11; + } + + // expected-error@+1 {{only loop iteration variables are allowed in 'lastprivate' clause in 'omp teams loop' directives}} + #pragma omp teams loop lastprivate(k) collapse(2) bind(thread) + for (i=0; i<1000; ++i) + for (j=0; j<1000; ++j) + for (k=0; k<1000; ++k) + z = i+j+k+11; + + // reduction + + // expected-error@+1 {{use of undeclared identifier 'undef_var'}} + #pragma omp teams loop reduction(+:undef_var) bind(thread) + for (i=0; i<1000; ++i) + z = i+11; +} + +template +void templ_test(T t) { + T i,z; + + // expected-error@+4 {{expected 2 for loops after '#pragma omp teams loop', but found only 1}} + // expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp teams loop collapse(C) bind(thread) + for (i=0; i<1000; ++i) + z = i+11; + + // expected-error@+1 {{only loop iteration variables are allowed in 'lastprivate' clause in 'omp teams loop' directives}} + #pragma omp teams loop lastprivate(z) bind(thread) + for (i=0; i<1000; ++i) { + z = i+11; + } +} + +void bar() +{ + templ_test(16); // expected-note {{in instantiation of function template specialization 'templ_test' requested here}} +} diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -5726,6 +5726,8 @@ return cxstring::createRef("OMPMaskedDirective"); case CXCursor_OMPGenericLoopDirective: return cxstring::createRef("OMPGenericLoopDirective"); + case CXCursor_OMPTeamsGenericLoopDirective: + return cxstring::createRef("OMPTeamsGenericLoopDirective"); case CXCursor_OverloadCandidate: return cxstring::createRef("OverloadCandidate"); case CXCursor_TypeAliasTemplateDecl: diff --git a/clang/tools/libclang/CXCursor.cpp b/clang/tools/libclang/CXCursor.cpp --- a/clang/tools/libclang/CXCursor.cpp +++ b/clang/tools/libclang/CXCursor.cpp @@ -826,6 +826,9 @@ case Stmt::OMPGenericLoopDirectiveClass: K = CXCursor_OMPGenericLoopDirective; break; + case Stmt::OMPTeamsGenericLoopDirectiveClass: + K = CXCursor_OMPTeamsGenericLoopDirective; + break; case Stmt::BuiltinBitCastExprClass: K = CXCursor_BuiltinBitCastExpr; } diff --git a/llvm/include/llvm/Frontend/OpenMP/OMP.td b/llvm/include/llvm/Frontend/OpenMP/OMP.td --- a/llvm/include/llvm/Frontend/OpenMP/OMP.td +++ b/llvm/include/llvm/Frontend/OpenMP/OMP.td @@ -1764,6 +1764,24 @@ VersionedClause, ]; } +def OMP_teams_loop : Directive<"teams loop"> { + let allowedClauses = [ + VersionedClause, + VersionedClause, + VersionedClause, + VersionedClause, + VersionedClause, + VersionedClause, + ]; + let allowedOnceClauses = [ + VersionedClause, + VersionedClause, + VersionedClause, + VersionedClause, + VersionedClause, + VersionedClause, + ]; +} def OMP_Metadirective : Directive<"metadirective"> { let allowedClauses = [VersionedClause]; let allowedOnceClauses = [VersionedClause];